{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7953d3845fef93a6",
   "metadata": {},
   "source": [
    "# 【开源实习】深度展开鲁棒量子启发式算法\n",
    "\n",
    "## 1 任务背景\n",
    "\n",
    "量子启发式算法应用中绝热演化路径对优化结果和计算时间影响较大，目前主要依赖人工经验调节，成为应用痛点。深度展开技术可以从数据集中自动学习绝热演化参数，可以提高量子启发式算法的鲁棒性、求解效果并减少迭代步数，有望推动更多应用落地。\n",
    "\n",
    "## 2 任务需求及实现方案\n",
    "\n",
    "基于MindQuantum设计实现一套基于深度展开的鲁棒量子启发式算法，该算法分训练和推理两个阶段，经过QUBO数据集上训练后，期望在同类QUBO问题上推理阶段的质量和速度显著提高，且全程无需人工调参。\n",
    "\n",
    "### 深度展开模拟分岔机\n",
    "\n",
    "本项目采用弹道模拟分岔机算法(ballistic simulated bifurcation, bSB)作为基线方法，在此基础上，首先将bSB算法转换为可微的形式，然后构建张量网络通过梯度下降的方法更新超参数，建立深度展开bSB算法(deep unfolding bSB, DUSB)。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e864986a",
   "metadata": {},
   "source": [
    "## 3 算法实现及效果\n",
    "\n",
    "下面基于 MindSpore Quantum 实现该算法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "460e653b",
   "metadata": {},
   "source": [
    "### 3.1 数据集介绍\n",
    "\n",
    "设置决策变量数为12，分别以固定值，均匀分布和双峰分布随机生成变量之间的相关系数。在每种方式下生成的相关系数可以表示变量之间的相互作用，也可以表示变量自身的偏置项。具体来说，对两个不同变量之间的耦合关系构成 Ising 问题中的矩阵J，而对单个变量自身的偏置项构成向量h。该问题的目标是计算Ising模型能量值最小。为评估不同算法在该问题上的求解性能，我们使用商业数学优化求解器 Gurobi 作为精确基准。对于每一个随机生成的实例，Gurobi 被用于计算该 Ising 模型的全局最优解，即最优的自选配置z和最小的能量值H。这些解不仅为模型评估提供准确的参考，也作为监督学习方法中的训练标签。随机生成900个案例，其中810个用于训练DUSB的超参数，其余90个作为测试集比较算法性能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7a871340",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import random\n",
    "import numpy as np\n",
    "import json\n",
    "import os\n",
    "import math\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import Tensor\n",
    "from torch.nn import Parameter\n",
    "import torch.storage\n",
    "from pathlib import Path\n",
    "from argparse import ArgumentParser\n",
    "from typing import List, Tuple\n",
    "from torch.optim import Adam\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy import ndarray\n",
    "import re\n",
    "from mindquantum.algorithm.qaia import QAIA, BSB\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7624296f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据集生成完毕\n"
     ]
    }
   ],
   "source": [
    "Nq = 12\n",
    "def generate_hyperedges(n, k, portion=0.2):\n",
    "    hyperedges = []\n",
    "    for i in range(1, k + 1):\n",
    "        for combination in itertools.combinations(range(n), i):\n",
    "            hyperedges.append(tuple(combination))\n",
    "    num_hyperedges = len(hyperedges)\n",
    "    num_to_select = int(num_hyperedges * portion)\n",
    "    random_hyperedges = random.sample(hyperedges, num_to_select)\n",
    "    return random_hyperedges\n",
    "def set_coef(hyperedges, coef=\"std\"):\n",
    "    model = {\"J\": [], \"c\": []}\n",
    "    for edge in hyperedges:\n",
    "        model[\"J\"].append(list(edge))\n",
    "        if coef == \"std\":\n",
    "            model[\"c\"].append(5)\n",
    "        elif coef == \"uni\":\n",
    "            model[\"c\"].append(random.uniform(-5, 5))\n",
    "        elif coef == \"exp\":\n",
    "            model[\"c\"].append(random.expovariate(1))\n",
    "        elif coef == \"bimodal\":\n",
    "            s1 = np.random.normal(1, 1)\n",
    "            s2 = np.random.normal(10, 1)\n",
    "            model[\"c\"].append(np.random.choice([s1, s2]))\n",
    "    return model\n",
    "def generate_data(Nq=Nq, kmax=2, p=0.2, nr=90, tort=\"train\"):\n",
    "    random.seed(2025)\n",
    "    np.random.seed(2025)\n",
    "    for k in range(2, kmax + 1):\n",
    "        for r in range(nr):\n",
    "            hyperedges = generate_hyperedges(Nq, k, portion=p)\n",
    "            for coef in [\"std\", \"uni\", \"bimodal\"]:\n",
    "                model = set_coef(hyperedges, coef=coef)\n",
    "                model_str = json.dumps(model)\n",
    "                directory = f\"{tort}_dataset\"\n",
    "                if not os.path.exists(directory):\n",
    "                    os.makedirs(directory)\n",
    "                with open(f\"{tort}_dataset/{coef}_p{p}_{r}.json\", \"w\") as f:\n",
    "                    f.write(model_str)\n",
    "# 生成训练集 90 * 9 = 810 个案例\n",
    "generate_data(p=0.3, nr=90, tort=\"train\")\n",
    "generate_data(p=0.6, nr=90, tort=\"train\")\n",
    "generate_data(p=0.9, nr=90, tort=\"train\")\n",
    "# 生成测试集 10 * 9 = 90 个案例\n",
    "generate_data(p=0.3, nr=10, tort=\"test\")\n",
    "generate_data(p=0.6, nr=10, tort=\"test\")\n",
    "generate_data(p=0.9, nr=10, tort=\"test\")\n",
    "print(\"数据集生成完毕\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bb1efda9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set parameter Username\n",
      "Academic license - for non-commercial use only - expires 2025-12-21\n",
      "7.4577178955078125\n",
      "0.7996931076049805\n",
      "标签生成完毕\n"
     ]
    }
   ],
   "source": [
    "import gurobipy as gp\n",
    "from gurobipy import GRB\n",
    "def solve_ising_instance(instance, N=12):\n",
    "    # 创建 Gurobi 模型并禁用日志输出\n",
    "    m = gp.Model(\"ising_k2\")\n",
    "    m.setParam(\"OutputFlag\", 0)\n",
    "    # 创建 N 个二元变量 x[i] ∈ {0,1}\n",
    "    x = m.addVars(N, vtype=GRB.BINARY, name=\"x\")\n",
    "    # 构造目标函数（使用二次表达式）\n",
    "    obj = gp.QuadExpr()\n",
    "    constant = 0.0\n",
    "    # 遍历对应的系数\n",
    "    for edge, coef in zip(instance[\"J\"], instance[\"c\"]):\n",
    "        if len(edge) == 1:\n",
    "            # 1阶项: coef * (2*x[i] - 1)\n",
    "            i = edge[0]\n",
    "            obj.add(2 * coef * x[i])\n",
    "            constant += -coef\n",
    "        elif len(edge) == 2:\n",
    "            # 2阶项: coef * (4*x[i]*x[j] - 2*x[i] - 2*x[j] + 1)\n",
    "            i, j = edge[0], edge[1]\n",
    "            obj.add(4 * coef * x[i] * x[j])\n",
    "            obj.add(-2 * coef * x[i])\n",
    "            obj.add(-2 * coef * x[j])\n",
    "            constant += coef\n",
    "        else:\n",
    "            print(\"警告：遇到非1阶或2阶的超边\", edge)\n",
    "    obj.addConstant(constant)\n",
    "    m.setObjective(obj, GRB.MINIMIZE)\n",
    "    m.optimize()\n",
    "    x_sol = m.getAttr(\"x\", x)\n",
    "    z_sol = {i: 2 * x_sol[i] - 1 for i in range(N)}\n",
    "    return x_sol, z_sol, m.objVal\n",
    "def save_label(folder=\"train_dataset\"):\n",
    "    time_list = []\n",
    "    for filename in os.listdir(folder):\n",
    "        if filename.endswith(\".json\"):\n",
    "            filepath = os.path.join(folder, filename)\n",
    "            with open(filepath, \"r\") as f:\n",
    "                instance = json.load(f)\n",
    "            t1 = time.time()\n",
    "            # 求解当前实例\n",
    "            x_sol, z_sol, obj_val = solve_ising_instance(instance, N=12)\n",
    "            t2 = time.time()\n",
    "            time_list.append(t2 - t1)\n",
    "            # 将求解结果以标签形式添加到原有字典中\n",
    "            instance[\"label\"] = {\n",
    "                \"x\": [x_sol[i] for i in range(12)],\n",
    "                \"z\": [z_sol[i] for i in range(12)],\n",
    "                \"obj_val\": obj_val,\n",
    "            }\n",
    "            with open(filepath, \"w\") as f:\n",
    "                json.dump(instance, f, indent=4)\n",
    "    time_avg = sum(time_list)\n",
    "    print(time_avg)\n",
    "folder = \"train_dataset\"\n",
    "save_label(folder)\n",
    "folder = \"test_dataset\"\n",
    "save_label(folder)\n",
    "print(\"标签生成完毕\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f37b7f4b",
   "metadata": {},
   "source": [
    "### 3.2 弹道模拟分岔机算法\n",
    "\n",
    "bSB算法是模拟分叉算法(simulated bifurcation, SB)的一种变体[1]。它源自量子非线性系统的动力学模拟，旨在求解二次无约束近似地求解能量函数：\n",
    "\n",
    "$$\n",
    "H = 0.5\\sum_{i,j\\in I}J_{i,j}z_iz_j + \\sum_{i\\in I}h_{i}z_i\n",
    "$$\n",
    "\n",
    "其中，$J_{i,i}=0$, $J_{i,j}=J_{j,i} (i,j=1,...n)$，$\\mathbf{z} = [z_1,...z_n] \\in \\{1, -1\\}^n$。\n",
    "\n",
    "为求解上述优化问题，bSB算法引入了一组连续时间的演化方程，模拟一个经典哈密顿系统的演化轨迹：\n",
    "\n",
    "$$\n",
    "\\dot{x}(t) = a_0 y(t),\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\dot{y}(t) = - (a_0 - a(t)) x(t) + c_0 \\left( J x(t) + h \\right),\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\text{if } |x_i(t)| > 1, \\text{ then } x_i(t) = \\text{sign}(x_i(t)), \\, y_i(t) = 0,\n",
    "$$\n",
    "\n",
    "其中，$\\mathbf{J} = (J_{i,j})$，$\\mathbf{h} = (h_i)$，$a_0$ 和 $c_0$ 是正的常数参数，$a(t)$ 是一个随计算周期 $t \\geq 0$ 单调递增的函数。$x_i(t)$ 是对应于 $z_i$ 的连续变量，$y_i(t)$ 是辅助变量。该算法会从随机初始点 $(\\mathbf{x}(0), \\mathbf{y}(0))$ 出发，当 $a(t) \\ll a_0$ 时，$x_i(t)$ 会迅速振荡，随着 $a(t)$ 的增大逐渐趋向于 1 或 -1。\n",
    "\n",
    "为便于数值求解，实际中我们通常采用离散时间模拟，将时间步长 $\\Delta$ 分段，使用欧拉方法进行迭代计算[2]：\n",
    "\n",
    "$$\n",
    "\\mathbf{x}(k+1) = \\mathbf{x}(k) + \\Delta \\mathbf{y}(k+1),\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf{y}(k+1) = \\mathbf{y}(k) - \\Delta \\left[ (1 - a(k\\Delta)) \\mathbf{x}(k) + c_0 \\left( \\mathbf{J} \\mathbf{x}(k) + \\mathbf{h} \\right) \\right],\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\text{if } |x_i(t)| > 1, \\text{ then } x_i(t) = \\text{sign}(x_i(t)), \\, y_i(t) = 0,\n",
    "$$\n",
    "\n",
    "其中，$\\Delta$ 是时间步长，即迭代周期。索引 $k = 0, ..., T - 1$ 表示迭代步数。需要注意的是，bSB 的收敛点依赖于初始点和参数的选择，因此 bSB 是一种近似算法。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11054d86",
   "metadata": {},
   "source": [
    "### 3.3 深度展开模拟分岔机\n",
    "\n",
    "定义可训练模型，然后读取数据集开始训练。  \n",
    "将深度展开的思想应用于bSB，可以通过引入可训练参数并结合梯度下降进一步提升算法性能。传统的 bSB 更新规则包含非连续的剪切操作，为了使用梯度下降算法，我们需要将SB的更新规则改为可微形式[3]。修改后的更新规则如下所示：\n",
    "\n",
    "$$\n",
    "\\tilde{x}(k) = x(k) + \\Delta_k y(k),\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\tilde{y}(k) = y(k) - \\Delta_k \\left[ (1 - a(k)) \\tilde{x}(k) + \\eta c_0 \\left( J \\tilde{x}(k) + h \\right) \\right],\n",
    "$$\n",
    "\n",
    "$$\n",
    "x(k+1) = \\phi_s(\\tilde{x}(k); \\Lambda),\n",
    "$$\n",
    "\n",
    "$$\n",
    "y(k+1) = \\tilde{y}(k) \\left[ 1 - \\psi_s(\\tilde{x}(k); A, B) \\right],\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\phi_s(x; \\Lambda) = \\frac{1}{\\Lambda} \\left( \\text{sw}(\\Lambda (x + 1)) - \\text{sw}(\\Lambda (x - 1)) \\right) - 1,\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\psi_s(x; A, B) = \\sigma \\left( A \\left| x \\right| - B \\right),\n",
    "$$\n",
    "\n",
    "其中，$a(k)$表示退火值，$\\Delta_k$表示第$k$次迭代的步长，$\\eta$是控制$J \\tilde{x}(k) + h$项强度的标量。以上参数均为可训练参数。函数$\\phi_s(x; \\Lambda)$和$\\psi_s(x; A, B)$是对剪切函数和方井函数的平滑、可微近似。$\\text{sw}(x) = x \\sigma(x)$是Swish激活函数，$\\sigma(x) = \\frac{1}{1 + e^{-x}}$是Sigmoid函数。\n",
    "\n",
    "由于引入了可微分结构，本模型可以在 PyTorch、TensorFlow 等深度学习框架中实现 end-to-end 训练。训练过程中通常采用均方误差损失（MSE loss）或比特错误率（BER）作为目标，通过大规模模拟数据训练模型参数，最终在少量迭代步中获得近似最优的变量取值。\n",
    "\n",
    "综上所述，DUSB不仅保留了物理动力学的可解释结构，还通过可微化处理使其具备了现代机器学习的表达与优化能力，为大规模组合优化问题（如 MIMO 检测）提供了一种兼具高性能与可扩展性的解决方案。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6454e5da85dea80",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.backends.cudnn.enabled = False\n",
    "torch.backends.cudnn.benchmark = False\n",
    "σ = F.sigmoid\n",
    "sw = lambda x: x * σ(x)\n",
    "φ_s = lambda x, Λ=10: (1 / Λ) * (sw(Λ * (x + 1)) - sw(Λ * (x - 1))) - 1\n",
    "ψ_s = lambda x, A=100, B=1.01: σ(A * (torch.abs(x) - B))\n",
    "class DU_SB(nn.Module):\n",
    "    def __init__(self, T: int, batch_size: int = 100):\n",
    "        super().__init__()\n",
    "        self.T = T\n",
    "        self.batch_size = batch_size\n",
    "        self.a = Parameter(torch.linspace(0, 1, T), requires_grad=True)\n",
    "        self.Δ = Parameter(torch.ones([T], dtype=torch.float32), requires_grad=True)\n",
    "        self.η = Parameter(torch.tensor([1.0], dtype=torch.float32), requires_grad=True)\n",
    "    def forward(self, J: Tensor, h: Tensor, **kwargs) -> Tensor:\n",
    "        B = self.batch_size\n",
    "        N = J.shape[0]\n",
    "        c_0: Tensor = 0.5 * math.sqrt(N - 1) / torch.linalg.norm(J, ord=\"fro\")\n",
    "        x = 0.02 * (torch.rand(N, B, device=J.device) - 0.5)\n",
    "        y = 0.02 * (torch.rand(N, B, device=J.device) - 0.5)\n",
    "        for k, Δ_k in enumerate(self.Δ):\n",
    "            y = y + Δ_k * (-(1 - self.a[k]) * x + self.η * c_0 * (J @ x + h))\n",
    "            x = x + Δ_k * y\n",
    "            x = φ_s(x)\n",
    "            y = y * (1 - ψ_s(x))\n",
    "        spins = x.T\n",
    "        return spins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "initial_id",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-10T14:29:08.554228200Z",
     "start_time": "2025-04-10T14:29:00.180373Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device: cuda\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 810/810 [00:00<00:00, 3310.72it/s]\n",
      " 81%|████████▏ | 24391/30000 [19:15<04:25, 21.11it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "# device = 'cpu'\n",
    "BASE_PATH = Path.cwd()\n",
    "LOG_PATH = BASE_PATH / \"log_qaia\"\n",
    "LOG_PATH.mkdir(exist_ok=True)\n",
    "class ValueWindow:\n",
    "    def __init__(self, nlen=10):\n",
    "        self.values: List[float] = []\n",
    "        self.nlen = nlen\n",
    "    def add(self, v: float):\n",
    "        self.values.append(v)\n",
    "        self.values = self.values[-self.nlen :]\n",
    "    @property\n",
    "    def mean(self):\n",
    "        return sum(self.values) / len(self.values) if self.values else 0.0\n",
    "def load_data(limit: int) -> List[Tuple]:\n",
    "    dataset = []\n",
    "    folder = \"train_dataset\"\n",
    "    files = sorted(os.listdir((folder)))\n",
    "    N = 12\n",
    "    for idx, filename in enumerate(tqdm(files)):\n",
    "        if idx > limit > 0:\n",
    "            break\n",
    "        filepath = os.path.join(folder, filename)\n",
    "        with open(filepath, \"r\") as f:\n",
    "            data = json.load(f)\n",
    "        h = np.zeros(N)\n",
    "        J = np.zeros((N, N))\n",
    "        hyperedges = data[\"J\"]\n",
    "        coeffs = data[\"c\"]\n",
    "        for edge, coef in zip(hyperedges, coeffs):\n",
    "            if len(edge) == 1:\n",
    "                h[edge[0]] += coef\n",
    "            elif len(edge) == 2:\n",
    "                i, j = edge\n",
    "                J[i, j] += coef\n",
    "                J[j, i] += coef\n",
    "            else:\n",
    "                print(\"warning: invalid input\", edge)\n",
    "        label = data.get(\"label\", None)\n",
    "        if label is not None:\n",
    "            x = label.get(\"x\", None)\n",
    "        J = -J\n",
    "        h = -h\n",
    "        J = torch.tensor(J, dtype=torch.float32, device=device)\n",
    "        h = torch.tensor(h, dtype=torch.float32, device=device).unsqueeze(1)\n",
    "        x = (\n",
    "            torch.tensor(x, dtype=torch.float32, device=device)\n",
    "            if label is not None\n",
    "            else None\n",
    "        )\n",
    "        dataset.append((J, h, x))\n",
    "    return dataset\n",
    "def train(args):\n",
    "    print(\"device:\", device)\n",
    "    exp_name = f\"DU-SB_T={args.n_iter}_lr={args.lr}\"\n",
    "    dataset = load_data(args.limit)\n",
    "    model: DU_SB = globals()[\"DU_SB\"](args.n_iter, args.batch_size).to(device)\n",
    "    optim = Adam(model.parameters(), args.lr)\n",
    "    init_step = 0\n",
    "    losses = []\n",
    "    if args.load:\n",
    "        print(f\">> resume from {args.load}\")\n",
    "        ckpt = torch.load(args.load, map_location=\"cpu\")\n",
    "        init_step = ckpt[\"steps\"]\n",
    "        losses.extend(ckpt[\"losses\"])\n",
    "        model.load_state_dict(ckpt[\"model\"], strict=False)\n",
    "        optim.load_state_dict(ckpt[\"optim\"])\n",
    "    loss_wv = ValueWindow(100)\n",
    "    steps_minor = 0\n",
    "    steps = init_step\n",
    "    model.train()\n",
    "    try:\n",
    "        pbar = tqdm(total=args.steps - init_step)\n",
    "        while steps < init_step + args.steps:\n",
    "            if not args.no_shuffle and steps_minor % len(dataset) == 0:\n",
    "                random.shuffle(dataset)\n",
    "            sample = dataset[steps_minor % len(dataset)]\n",
    "            J, h, bits = sample\n",
    "            spins = model(J, h)\n",
    "            loss_each = torch.stack([ber_loss(sp, bits, args.loss_fn) for sp in spins])\n",
    "            loss = getattr(loss_each, args.agg_fn)()\n",
    "            loss_for_backward: Tensor = loss / args.grad_acc\n",
    "            loss_for_backward.backward()\n",
    "            loss_wv.add(loss.item())\n",
    "            steps_minor += 1\n",
    "            if args.grad_acc == 1 or steps_minor % args.grad_acc:\n",
    "                optim.step()\n",
    "                optim.zero_grad()\n",
    "                steps += 1\n",
    "                pbar.update()\n",
    "            if steps % 50 == 0:\n",
    "                losses.append(loss_wv.mean)\n",
    "    except KeyboardInterrupt:\n",
    "        pass\n",
    "    ckpt = {\n",
    "        \"steps\": steps,\n",
    "        \"losses\": losses,\n",
    "        \"model\": model.state_dict(),\n",
    "        \"optim\": optim.state_dict(),\n",
    "    }\n",
    "    torch.save(ckpt, LOG_PATH / f\"{exp_name}.pth\")\n",
    "    with torch.no_grad():\n",
    "        params = {\n",
    "            \"deltas\": model.Δ.detach().cpu().numpy().tolist(),\n",
    "            \"eta\": model.η.detach().cpu().item(),\n",
    "            \"a\": model.a.detach().cpu().numpy().tolist(),\n",
    "        }\n",
    "        with open(LOG_PATH / f\"{exp_name}.json\", \"w\", encoding=\"utf-8\") as fh:\n",
    "            json.dump(params, fh, indent=2, ensure_ascii=False)\n",
    "    plt.plot(losses)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(LOG_PATH / f\"{exp_name}.png\", dpi=600)\n",
    "def ber_loss(spins: Tensor, bits: Tensor, loss_fn: str = \"mse\") -> Tensor:\n",
    "    bits_final = (spins + 1) / 2\n",
    "    if loss_fn in [\"l2\", \"mse\"]:\n",
    "        return F.mse_loss(bits_final, bits)\n",
    "    if loss_fn in [\"l1\", \"mae\"]:\n",
    "        return F.l1_loss(bits_final, bits)\n",
    "    if loss_fn == \"bce\":\n",
    "        pseudo_logits = bits_final * 2 - 1\n",
    "        return F.binary_cross_entropy_with_logits(pseudo_logits, bits)\n",
    "    raise ValueError(f\"Unsupported loss function: {loss_fn}\")\n",
    "parser = ArgumentParser()\n",
    "parser.add_argument(\"-T\", \"--n_iter\", default=15, type=int)\n",
    "parser.add_argument(\n",
    "    \"-B\", \"--batch_size\", default=32, type=int, help=\"SB candidate batch size\")\n",
    "parser.add_argument(\"--steps\", default=20000, type=int)\n",
    "parser.add_argument(\"--loss_fn\", default=\"bce\", choices=[\"mse\", \"l1\", \"bce\"])\n",
    "parser.add_argument(\"--agg_fn\", default=\"mean\", choices=[\"mean\", \"max\"])\n",
    "parser.add_argument(\"--grad_acc\", default=1, type=int, help=\"training batch size\")\n",
    "parser.add_argument(\"--lr\", default=1e-4, type=float)\n",
    "parser.add_argument(\"--load\", help=\"ckpt to resume\")\n",
    "parser.add_argument(\n",
    "    \"-L\", \"--limit\", default=-1, type=int, help=\"limit dataset n_sample\")\n",
    "parser.add_argument(\"--overfit\", action=\"store_true\", help=\"overfit to given dataset\")\n",
    "parser.add_argument(\"--no_shuffle\", action=\"store_true\", help=\"no shuffle dataset\")\n",
    "parser.add_argument(\"--log_every\", default=50, type=int)\n",
    "args, unknown = parser.parse_known_args()\n",
    "if args.overfit:\n",
    "    print(\"[WARN] you are trying to overfit to the given dataset!\")\n",
    "train(args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e1cd516",
   "metadata": {},
   "source": [
    "### 3.4 测试结果\n",
    "\n",
    "在并行数和迭代周期数一致的情况下，DUSB的能量值低于SB，实现了求解质量的提升。Gurobi的能量值最小，但是计算效率较低。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f27c698c87450afe",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-11T07:26:59.693188100Z",
     "start_time": "2025-04-11T07:26:59.629799900Z"
    }
   },
   "outputs": [],
   "source": [
    "σ = lambda x: 1 / (1 + np.exp(-x))\n",
    "sw = lambda x: x * σ(x)\n",
    "φ_s = lambda x, Λ=10: (1 / Λ) * (sw(Λ * (x + 1)) - sw(Λ * (x - 1))) - 1\n",
    "ψ_s = lambda x, A=100, B=1.01: σ(A * (np.abs(x) - B))\n",
    "class DUSB(BSB):\n",
    "    def __init__(self, J: ndarray, h: ndarray, deltas: List[float], eta: float, a: List[float], x: ndarray = None, batch_size: int = 100):\n",
    "        super().__init__(J, h, x, len(deltas), batch_size, dt=1, xi=None)\n",
    "        self.N = self.J.shape[0]\n",
    "        if self.x is None:\n",
    "            self.x = 0.02 * (np.random.rand(self.N, self.batch_size) - 0.5)\n",
    "        if self.y is None:\n",
    "            self.y = 0.02 * (np.random.rand(self.N, self.batch_size) - 0.5)\n",
    "        self.Δ = deltas\n",
    "        self.η = eta\n",
    "        self.c_0 = self.xi * self.η\n",
    "        self.a_m1 = np.array(a) - 1\n",
    "    def update(self):\n",
    "        for k, Δ_k in enumerate(self.Δ):\n",
    "            self.y += Δ_k * (self.a_m1[k] * self.x + self.c_0 * (self.J @ self.x + self.h))\n",
    "            self.x += Δ_k * self.y\n",
    "            self.x = φ_s(self.x)\n",
    "            self.y *= 1 - ψ_s(self.x)\n",
    "    def update_hard(self):\n",
    "        for k, Δ_k in enumerate(self.Δ):\n",
    "            self.y += Δ_k * (self.a_m1[k] * self.x + self.c_0 * (self.J @ self.x + self.h))\n",
    "            self.x += Δ_k * self.y\n",
    "            cond = np.abs(self.x) > 1\n",
    "            self.x = np.where(cond, np.sign(self.x), self.x)  # limit x to vrng [-1, +1]\n",
    "            self.y = np.where(cond, np.zeros_like(self.x), self.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5e5cfbfedd2b59a5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-11T07:27:27.196036Z",
     "start_time": "2025-04-11T07:27:27.132392100Z"
    }
   },
   "outputs": [],
   "source": [
    "BASE_PATH = Path.cwd()\n",
    "LOG_PATH = BASE_PATH / \"log_qaia\"\n",
    "def solver_qaia_lib(qaia_cls, J: ndarray, h: ndarray, n_iter) -> ndarray:\n",
    "    bs = 1\n",
    "    solver: QAIA = qaia_cls(J, h, batch_size=bs, n_iter=n_iter)\n",
    "    solver.update()  # [rb*N, B]\n",
    "    if bs > 1:\n",
    "        energy = min(solver.calc_energy())  # [1, B]\n",
    "    else:\n",
    "        energy = min(solver.calc_energy())\n",
    "    return energy\n",
    "def solver_DU_SB(J: ndarray, h: ndarray, deltas, eta, a) -> ndarray:\n",
    "    bs = 1\n",
    "    solver = DUSB(J, h, deltas, eta, a, batch_size=bs)\n",
    "    solver.update_hard()  # [rb*N, B]\n",
    "    if bs > 1:\n",
    "        energy = min(solver.calc_energy())  # [1, B]\n",
    "    else:\n",
    "        energy = min(solver.calc_energy())\n",
    "    return energy\n",
    "def qaia_mld_solver(J: ndarray, h: ndarray, run_cfg, DU_SB_weights) -> ndarray:\n",
    "    filename = DU_SB_weights.name\n",
    "    pattern = r\"T=(\\d+)\"\n",
    "    match = re.search(pattern, filename)\n",
    "    n_iter = int(match.group(1))\n",
    "    with open(DU_SB_weights, \"r\", encoding=\"utf-8\") as fh:\n",
    "        params = json.load(fh)\n",
    "        deltas: List[float] = params[\"deltas\"]\n",
    "        eta: float = params[\"eta\"]\n",
    "        a: float = params[\"a\"]\n",
    "    if run_cfg == \"baseline\":\n",
    "        return solver_qaia_lib(BSB, J, h, n_iter)\n",
    "    return solver_DU_SB(J, h, deltas, eta, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c560bb91e41d4ce3",
   "metadata": {
    "ExecuteTime": {
     "start_time": "2025-04-11T07:36:55.165145800Z"
    },
    "is_executing": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 90/90 [00:00<00:00, 3461.66it/s]\n",
      "100%|██████████| 90/90 [00:00<00:00, 849.67it/s]\n",
      "100%|██████████| 90/90 [00:00<00:00, 1052.51it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHbCAYAAABGPtdUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5XUlEQVR4nO3dd3wUdf7H8dfuZndTSCMVSCGh915CE6REBU+xnQ1FUU/EU8AGPxSVUznr2XsBFRV7ASlRipTQDTXUJISShJpCQtru/P6IRCMtgSSbhPfz8dgH7Mx3vvOZzJ28M/Od75gMwzAQERERkVrP7OoCRERERKRyKNiJiIiI1BEKdiIiIiJ1hIKdiIiISB2hYCciIiJSRyjYiYiIiNQRCnYiIiIidYSCnYiIiEgdoWAnIiIiUkco2ImIiIjUEQp2IuIy06ZNw2QynfazYsUKV5coIlKruLm6ABGRKVOmEBUVddLypk2buqAaEZHaS8FORFzu0ksvpWvXri6tITc3Fy8vL5fWICJyvnQrVkRqtJSUFEwmEy+88ALvvvsuTZo0wW63061bN1avXn1S+61bt3LNNddQv3593N3d6dq1Kz/++GOZNiduAS9evJh77rmH4OBgwsLCSte/8cYbREdH4+HhQffu3VmyZAn9+/enf//+ABw7dgwvLy/uv//+k/a/d+9eLBYLU6dOrdwfhIhIOeiKnYi4XFZWFocOHSqzzGQyERAQUPr9s88+Iycnh3/961+YTCaee+45rrrqKpKSkrBarQBs3ryZ3r1706hRIyZMmICXlxdffvklV155Jd988w3Dhw8vs4977rmHoKAgJk+eTG5uLgBvvfUW9957L3379mXcuHGkpKRw5ZVX4u/vXxr+6tWrx/Dhw5k5cyYvvfQSFoultM/PP/8cwzC46aabquRnJSJyRoaIiIt89NFHBnDKj91uNwzDMJKTkw3ACAgIMI4cOVK67Q8//GAAxk8//VS6bODAgUa7du2M/Pz80mVOp9Po1auX0axZs5P226dPH6O4uLh0eUFBgREQEGB069bNKCoqKl0+bdo0AzAuuuii0mXz5s0zAGPOnDlljql9+/Zl2omIVCfdihURl3vjjTeIi4sr85kzZ06ZNv/85z/x9/cv/d63b18AkpKSADhy5AgLFizguuuuIycnh0OHDnHo0CEOHz5MbGwsO3bsYN++fWX6vPPOO8tcbVuzZg2HDx/mzjvvxM3tzxsaN910U5l9AwwaNIiGDRsyY8aM0mWbNm1iw4YN3Hzzzef5ExEROTe6FSsiLte9e/ezPjwRERFR5vuJoHX06FEAdu7ciWEYPPbYYzz22GOn7OPAgQM0atSo9Pvfn8TdvXs3cPLTuG5ubjRu3LjMMrPZzE033cRbb71FXl4enp6ezJgxA3d3d6699tozHouISFVRsBORWuGvV9b+yjAMAJxOJwAPPvggsbGxp2z798Dm4eFxXjXdcsstPP/883z//ffccMMNfPbZZwwbNgxfX9/z6ldE5Fwp2IlInRAdHQ2A1Wpl0KBB59RHZGQkUHL1b8CAAaXLi4uLSUlJoX379mXat23blk6dOjFjxgzCwsJITU3ltddeO8cjEBE5fxpjJyJ1QnBwMP379+edd94hLS3tpPUHDx48ax9du3YlICCA9957j+Li4tLlM2bMKL3l+3cjRoxg/vz5vPzyywQEBHDppZee+0GIiJwnXbETEZebM2cOW7duPWl5r169MJvL//vnG2+8QZ8+fWjXrh133nkn0dHRZGRkEB8fz969e1m/fv0Zt7fZbDzxxBP8+9//5uKLL+a6664jJSWFadOm0aRJE0wm00nb3HjjjTz88MN89913jB49unTqFRERV1CwExGXmzx58imXf/TRR6WTApdH69atWbNmDU8++STTpk3j8OHDBAcH06lTp9Pu4+/uvfdeDMPgxRdf5MEHH6RDhw78+OOP3Hfffbi7u5/UPiQkhCFDhvDzzz8zYsSIctcqIlIVTMaJkcciInJKTqeToKAgrrrqKt57772T1g8fPpyNGzeyc+dOF1QnIvInjbETEfmL/Px8/v777scff8yRI0dOefUwLS2N2bNn62qdiNQIumInIvIXixYtYty4cVx77bUEBASwbt06PvjgA1q1asXatWux2WwAJCcns2zZMt5//31Wr17Nrl27CA0NdXH1InKh0xg7EZG/aNy4MeHh4bz66qscOXKE+vXrc8stt/Df//63NNQBLF68mNtuu42IiAimT5+uUCciNYKu2ImIiIjUERpjJyIiIlJHKNiJiIiI1BEKdiIiIiJ1hIKdiIiISB2hYCciIiJSRyjYiYiIiNQRCnYiIiIidYSCnYiIiEgdoWAnIiIiUkco2ImIiIjUEQp2IiIiInWEgp2IiIhIHaFgJyIiIlJHKNiJiIiI1BEKdiIiIiJ1hIKdiIiISB2hYCciIiJSRyjYiYiIiNQRCnYiIiIidYSCnYiIiEgd4bJgl5KSwqhRo4iKisLDw4MmTZrw+OOPU1hYWKbdhg0b6Nu3L+7u7oSHh/Pcc8+5qGIRERGRms3NVTveunUrTqeTd955h6ZNm7Jp0ybuvPNOcnNzeeGFFwDIzs5myJAhDBo0iLfffpuNGzdy++234+fnx1133eWq0kVERERqJJNhGIarizjh+eef56233iIpKQmAt956i0mTJpGeno7NZgNgwoQJfP/992zdutWVpYqIiIjUOC67YncqWVlZ1K9fv/R7fHw8/fr1Kw11ALGxsTz77LMcPXoUf3//cvXrdDrZv38/3t7emEymSq9bREREpKoYhkFOTg4NGzbEbD7zKLoaE+x27tzJa6+9VnobFiA9PZ2oqKgy7UJCQkrXnS7YFRQUUFBQUPp93759tG7dugqqFhEREakee/bsISws7IxtKj3YTZgwgWefffaMbRITE2nZsmXp93379nHJJZdw7bXXcuedd553DVOnTuXJJ588afmePXvw8fE57/5FREREqkt2djbh4eF4e3uftW2lj7E7ePAghw8fPmOb6Ojo0tur+/fvp3///vTs2ZNp06aVucR4yy23kJ2dzffff1+6bOHChVx88cUcOXKk3FfsTvxAsrKyFOxERESkVsnOzsbX17dcOabSr9gFBQURFBRUrrb79u1jwIABdOnShY8++uik+8YxMTFMmjSJoqIirFYrAHFxcbRo0eKM4+vsdjt2u/3cD0JERESkFnLZPHb79u2jf//+RERE8MILL3Dw4EHS09NJT08vbXPjjTdis9kYNWoUmzdvZubMmbzyyiuMHz/eVWWLiIiI1Fgue3giLi6OnTt3snPnzpMGAp64O+zr68v8+fMZM2YMXbp0ITAwkMmTJ2sOOxERkSrkcDgoKipydRkXDKvVisViqZS+atQ8dlWlIvemRURELlSGYZCenk5mZqarS7ng+Pn5ERoaespp2Vw6xk5ERERqpxOhLjg4GE9PT839Wg0MwyAvL48DBw4A0KBBg/PqT8FOREREcDgcpaEuICDA1eVcUDw8PAA4cOAAwcHB53Vb1mUPT4iIiEjNcWJMnaenp4sruTCd+Lmf79hGBTsREREppduvrlFZP3cFOxEREZE6QsFOREREpI5QsBMREZFabeTIkZhMJkwmE1arlZCQEAYPHsyHH36I0+ksbWcymcq8pvSv21955ZWl35OTk7nxxhtp2LAh7u7uhIWFccUVV7B169YyfZ34uLm5ERERwfjx48u80tQVFOxERESk1rvkkktIS0sjJSWFOXPmMGDAAO6//36GDRtGcXFxufspKipi8ODBZGVl8e2337Jt2zZmzpxJu3btTprf76OPPiItLY3k5GTefPNNPvnkE5566qlKPrKK0XQnlcgwDAwDzGYNPBUREalOdrud0NBQABo1akTnzp3p2bMnAwcOZNq0adxxxx3l6mfz5s3s2rWLX3/9lcjISAAiIyPp3bv3SW1PTCoMEB4ezhVXXMG6desq6YjOja7YVZJn526lxzO/8tuOg64uRURE5LwZhkFeYbFLPpX1UqyLL76YDh068O2335Z7m6CgIMxmM19//TUOh6Pc223fvp0FCxbQo0ePcym10uiKXSU5mlvIgZwCFm8/SP8Wwa4uR0RE5LwcL3LQevI8l+x7y5RYPG2VE1FatmzJhg0byt2+UaNGvPrqqzz88MM8+eSTdO3alQEDBnDTTTcRHR1dpu0NN9yAxWKhuLiYgoIChg0bxsSJEyul7nOlK3aVpH+LIAAWb9MVOxERkZrCMIwKzxE3ZswY0tPTmTFjBjExMXz11Ve0adOGuLi4Mu3+97//kZCQwPr165k1axbbt29nxIgRlVl+hemKXSXp1TQQN7OJpEO5pB7OIyJAM3eLiEjt5WG1sGVKrMv2XVkSExOJiooCwNvbm6ysrJPaZGZm4uvrW2aZt7c3l19+OZdffjlPPfUUsbGxPPXUUwwePLi0TWhoKE2bNgWgRYsW5OTkcMMNN/DUU0+VLq9uumJXSXzcrXSO9Adg8fYDLq5GRETk/JhMJjxtbi75VNZbGBYsWMDGjRu5+uqrgZLwtXbt2jJtHA4H69evp3nz5mf8WbRs2ZLc3Nwz7u/EO16PHz9+npWfO12xq0T9WwSxKvkIi7YdZERMY1eXIyIicsEoKCggPT0dh8NBRkYGc+fOZerUqQwbNoxbbrkFgPHjxzNq1ChatmzJ4MGDyc3N5bXXXuPo0aOlT80mJCTw+OOPM2LECFq3bo3NZmPx4sV8+OGHPPLII2X2mZmZSXp6Ok6nkx07djBlyhSaN29Oq1atqv34T1Cwq0QXNQ/iubnbWL7rMAXFDuxulXcpWURERE5v7ty5NGjQADc3N/z9/enQoQOvvvoqt956K2ZzyQ3KG264AcMweOmll5gwYQKenp506dKF3377jZCQEADCwsJo3LgxTz75JCkpKZhMptLv48aNK7PP2267DSi5ohcaGkq/fv145plncHNzXbwyGZX1THENlp2dja+vL1lZWfj4+FTZfgzDoMczv3Igp4BPR/WgT7PAKtuXiIhIZcrPzyc5OZmoqCjc3d1dXc4F50w//4rkGI2xq0Qmk4mLmv/xdKzG2YmIiEg1U7CrZBf9Me3JIk17IiIiItVMwa6S9W0ahNkEOw4cY1+m656KERERkQuPgl0l8/W00jnij2lPdNVOREREqpGCXRU4Mc5u0TaNsxMREZHqo2BXBU68K3bZzkMUFjtdXI2IiIhcKBTsqkCbhj4E1rORW+hg7e6jri5HRERELhAKdlXAbDbRr9kft2M17YmIiIhUEwW7KnJi2pOKPkCRuj2Bgvy8qihJRERE6jgFuyrSr1kQJhNsTc8hPSu/XNus+PwZIj67iIQP/l3F1YmIiEhdpGBXRfy9bHQI8wPK9xaKvTs30WHr/wBoejAOp8NRleWJiIjUGQcPHmT06NFERERgt9sJDQ0lNjaWZcuWAdC4cWNMJhMmkwmLxULDhg0ZNWoUR4/WvXHwCnaVJT8bispOSNz/xO3Y7We+Het0OMie+S88TIUABJDFrg3LqqZOERGROubqq6/m999/Z/r06Wzfvp0ff/yR/v37c/jw4dI2U6ZMIS0tjdTUVGbMmMFvv/3Gfffd58Kqq4abqwuoM+b9H/z+CVg9wTMAPOtzu9mHxlYHu3ZEU1jQFpvdfspNV335LD2LNpFn2Em1RtOyOJFDv8+iWad+1XwQIiIitUtmZiZLlixh0aJFXHTRRQBERkbSvXv3Mu28vb0JDQ0FoFGjRtx66618/vnn1V5vVVOwqyz5mSV/FuVBVh5k7cEHuNICsJxNL20mcvQ3ePsFlNlsX1Ii7be+DCbY2PoBTG522Pg49fcvqtbyRUREyjCMkn/TXMHqCSZTuZrWq1ePevXq8f3339OzZ0/sp7mI8lf79u3jp59+okePHudbaY1jMgzDcHURVS07OxtfX1+ysrLw8fGpkn38uPMHNh9IwFxcgKm4EHNxPqbifLKzjhK9fw3XHssiwxSJ5+3fEhLWBCi5BZv4bH/aFG5gs609rR5ZxOGMPQS92wGnYSJzzGbqBzeqknpFRET+Kj8/n+TkZKKionB3d4fCXHimoWuK+b/9YPMqd/NvvvmGO++8k+PHj9O5c2cuuugirr/+etq3bw+UjLFLS0vDarXicDjIz8+nR48ezJ07Fz8/vyo6iIo56ef/FxXJMRpjV0mW7V/OZzu+5tPkn/hkzzympy1m2sGVfFu4nRcCfYgNb8Rv9Q5T8MEgdm1YDsDqb16kTeEG8gw7fte/jdliIahhY3ZZojGbDJJW/OjioxIREan5rr76avbv38+PP/7IJZdcwqJFi+jcuTPTpk0rbfPQQw+RkJDAhg0b+PXXXwEYOnQojjr2sKJuxVaSiyMuplG9RhgYGIaBEyeGYeAwHCzes5jUnFReCPBnmq+DW+JuJH37vXTa/AKYYEPL++kZ3aa0rwOh/WiyLwl2xAGjXXdQIiJy4bJ6llw5c9W+K8jd3Z3BgwczePBgHnvsMe644w4ef/xxRo4cCUBgYCBNmzYFoFmzZrz88svExMSwcOFCBg0aVJnVu5SCXSWJbRxLbOPYU64b32U8P+36iTd/f4P04xm8FOhNSNYH9A/0JNMcRkCUicWrnsVsMmOz2OjQsgfsm0aznBU4iouxuOk0iYhINTOZKnQ7tKZp3bo133///WnXWywWAI4fP37aNrVRjbgVW1BQQMeOHTGZTCQkJJRZt2HDBvr27Yu7uzvh4eE899xzrinyPLiZ3RjebDg/Xz2HiV0n4O90I8PNjZk+3syrV8Rn2z7n08RP+XjLx7y/8X0+zJlDFl74ksuOdQtdXb6IiEiNdfjwYS6++GI+/fRTNmzYQHJyMl999RXPPfccV1xxRWm7nJwc0tPTSUtLY9WqVTz00EMEBQXRq1cvF1Zf+WrEpaCHH36Yhg0bsn79+jLLs7OzGTJkCIMGDeLtt99m48aN3H777fj5+XHXXXe5qNpzZ7VYubHNTVzV/CrenvUoOe4W/ELDS27dGk6chpNPEj/h94MJxPl34Jqjyzm6fjZ0H+zq0kVERGqkevXq0aNHD/73v/+xa9cuioqKCA8P58477+T//u//SttNnjyZyZMnAxAUFES3bt2YP38+AQEBp+u6VnJ5sJszZw7z58/nm2++Yc6cOWXWzZgxg8LCQj788ENsNhtt2rQhISGBl156qVYGuxPcrR6MHf7iKdcdPH6QWUmzmBfkwTVHISj9t2quTkREpPaw2+1MnTqVqVOnnrZNSkpK9RXkYi69FZuRkcGdd97JJ598gqfnyQMl4+Pj6devHzabrXRZbGws27ZtO+NrQAoKCsjOzi7zqS1GtB4BwOriJNLMbjR17OLg/hTXFiUiIiK1gsuCnWEYjBw5krvvvpuuXbuesk16ejohISFllp34np6eftq+p06diq+vb+knPDy88gqvYq0DWtMlpAsOw8Hb/iV1p6z4wcVViYiISG1Q6cFuwoQJpS/aPd1n69atvPbaa+Tk5DBx4sTKLoGJEyeSlZVV+tmzZ0+l76MqjWhVctVunreZ4yYTlqRfXFyRiIiI1AaVPsbugQceKJ0z5nSio6NZsGAB8fHxJ736o2vXrtx0001Mnz6d0NBQMjIyyqw/8f3E+95OxW63l+uVIjVV//D+NKrXiH3H9vFTPS8uzV5NUWEBVlvtPSYRERGpepUe7IKCgggKCjpru1dffZWnnnqq9Pv+/fuJjY1l5syZpe9ui4mJYdKkSRQVFWG1WgGIi4ujRYsW+Pv7V3bpNYbFbOGmVjfx3OrnmO7jyzU5+0hc8yttel3m6tJERESkBnPZGLuIiAjatm1b+mnevDkATZo0ISwsDIAbb7wRm83GqFGj2Lx5MzNnzuSVV15h/Pjxriq72gxvOhwvqxepNgvLPdzJ3jjb1SWJiIhIDVcjJig+HV9fX+bPn09ycjJdunThgQceYPLkybV6qpPyqmerx1XNrgLgEx9vQjOWuLgiERERqelcPo/dCY0bN8YwjJOWt2/fniVLLsxQc2PLG5mxZQbLPT1wWPaTnrqD0Ihmri5LREREaqgafcXuQhfmHcbFERcD8KmPN3nTrmHn+mWnbW84naz+4U1Sp7Rm1as3V1eZIiIiUkMo2NVwN7cuCWg/1fOiyG0fkd9ezor3x1NYkF+mXdKmlWyd2oduv08kwrmP7kd+Ys+O9afqUkRERCrRokWLMJlMZGZmnrbNtGnT8PPzq/JaFOxquM7BnWkd0JpCs4lrGjXgurAgfj/2FStf7M7O9UvJzjzMijfuIOKrS2hVtJk8w85eU8lUMHsXvOvi6kVERKpHeno6999/P02bNsXd3Z2QkBB69+7NW2+9RV5enqvL45///Cfbt2+v8v3UmDF2cmomk4nn+j3H86ufZ9n+Zey0wU6bDfwNmq0cxWW/FjMq+xAmE6yr14+G173Ewa0rCVs+huZpP1FY8CI2u7urD0NERKTKJCUl0bt3b/z8/HjmmWdo164ddrudjRs38u6779KoUSP+8Y9/VLhfwzBwOBy4uZ1/XPLw8MDDw+O8+zkbXbGrBSJ9Inl94Oss/udinur9FD2DumExYIfdxisBnrzoF8bGi6fR+cGfCI1oRtv+13IIPwLIYvOima4uX0REpErdc889uLm5sWbNGq677jpatWpFdHQ0V1xxBbNnz+byyy8nJSUFk8lEQkJC6XaZmZmYTCYWLVoE/HlLdc6cOXTp0gW73c7SpUspKCjgvvvuIzg4GHd3d/r06cPq1atPqmPZsmW0b98ed3d3evbsyaZNm0rX6VasnMTH5sMVTa/gvcs+ZPENS7napx8AH/tbONTYr7Sd1WZnR8MrADD//okrShURkVrOMAzyivJc8jnVLBmnc/jwYebPn8+YMWPw8vI6ZRuTyVShY58wYQL//e9/SUxMpH379jz88MN88803TJ8+nXXr1tG0aVNiY2M5cuRIme0eeughXnzxRVavXk1QUBCXX345RUVFFdr3+dKt2FrK1+7LE8PfwG3FU8zcNpMJSybwyWWf0Ny/ZKLn8Ivvgk+n0+74Gk2TIiIiFXa8+Dg9Puvhkn2vvHElnlbPcrXduXMnhmHQokWLMssDAwPJzy950HDMmDGMHj263PufMmUKgwcPBiA3N5e33nqLadOmcemllwLw3nvvERcXxwcffMBDDz1Uut3jjz9eut306dMJCwvju+++47rrriv3vs+XrtjVco90f4QeoT3IK87jvgX3cSS/5LeHsKZt2WzrgNlkkPyLHqIQEZELy6pVq0hISKBNmzYUFBRUaNuuXbuW/n3Xrl0UFRXRu3fv0mVWq5Xu3buTmJhYZruYmJjSv9evX58WLVqc1Kaq6YpdLWc1W3mx/4vcMPsG9uTsYfyi8bw3+D2sFivH290Ea9cTlfodjuKpWCph8KeIiFwYPNw8WHnjSpftu7yaNm2KyWRi27ZtZZZHR0eX9PXHAwtmc8m1rL/e5j3dbdLT3dKtDXTFrg7wtfvy2sWv4WX1Ym3GWp5Z9QyGYdB20M1k4UUoB9m89AdXlykiIrWIyWTC0+rpkk9FxsQFBAQwePBgXn/9dXJzc0/bLigoCIC0tLTSZX99kOJ0mjRpgs1mY9myP18QUFRUxOrVq2ndunWZtitWrCj9+9GjR9m+fTutWrUq76FUCgW7OqKJXxOe6/ccJkx8vf1rPt7yMe4eXiQGXQZA8eppri1QRESkirz55psUFxfTtWtXZs6cSWJiItu2bePTTz9l69atWCwWPDw86NmzZ+lDEYsXL+bRRx89a99eXl6MHj2ahx56iLlz57JlyxbuvPNO8vLyGDVqVJm2U6ZM4ddff2XTpk2MHDmSwMBArrzyyio66lNTsKtD+oX1Y3yX8QC8sOYFJi2dhHefEQC0O7aMwxl7XVmeiIhIlWjSpAm///47gwYNYuLEiXTo0IGuXbvy2muv8eCDD/Kf//wHgA8//JDi4mK6dOnC2LFjeeqpp8rV/3//+1+uvvpqRowYQefOndm5cyfz5s3D39//pHb3338/Xbp0IT09nZ9++gmbzVbpx3smJqMizxTXUtnZ2fj6+pKVlYWPj4+ry6lShmHwwaYPeO3313AaThr7NObf2/cz5PhOVjQdS8+bn3R1iSIiUgPl5+eTnJxMVFQU7u6a2L66nennX5Ecoyt2dYzJZOKOdnfwYeyHBHsGk5KdwiOhDr70rkeDpK8wnE5XlygiIiJVRI9J1lFdQrrw9eVfM2npJJbsW8J/AusT657L9fE/0LX38GqpYcOibzBWvIWJk8Okj7sbkQFelB0ea4LOI6BN9dQnFbDxaziwBQY8Cmb9PigiUlMp2NVh/u7+vD7wdT7e/DEvr3mRefW8SEh8lLvz93PNwDFVvn+/3x4jwrnv1CvzgcxTLE/fCK2vhArOEi5VqLgQfvw3FOVB4z7Q5GJXVyQiIqehYFfHmU1mRrYdSbgzgP+umki61cyUPW8R/8Esnrj+c7y9/Kpkv6nbE4hw7qPQsJDQ8UlMZkvput92HGTvkeNc1bkRfZuVPH6OYcCscZB7AA5ug+CWVVKXnIN9a0tCHUDyEgU7EZEaTMHuAjGw/eW0bdSZJ7+5gSX2o8x328v2z/oyvtMUBnQtufVZkJ/HjjW/kLN5HsEHllNksuM/cgYhYU0qvL/9q74jAtjm3oHuw/9dZt2qhTv5bt42jh8PpW+HLn+uWP85JC+GlCUKdjVJypJT/11ERGocDZa5gIQENOLNu37jfv/h+DqcpNjggU2P8eR7l7P6uVgcUxvT9pcRxKR9ShNHEi2LE3F8cAn7kjZXeF++u+MAyIuOPWldz+gAAFYkH8bp/MtD2VF9S/5M/q3iBydV56/nY986KMhxXS0iUuWcesjOJSrr564rdhegO/4xhX67r+E/c28nwb2Ar20p/BLo4Ap3DwZme1Hs1Q2jcR8abniTMCONAx8PY/f13xDZsnO5+j9yYB/NC7eACSJjrj5pffswXzxtFjLzikhMz6ZNQ9+SFY37lfyZshScTg3SrwmK8mHPqpK/2+pB4TFIXQHNBru2LhGpdDabDbPZzP79+wkKCsJms1XoDRBybgzDoLCwkIMHD2I2m8973jsFuwtU88j2TL9jJS99dS8/5sVz1ALTfX2Y7gvdQutxTbOmhHWbRcqHw2nsTOXoF1ewc/gXNO3Q+6x971z2Ld1NBrss0TSJaHbSeqvFTLfG9Vm8/SDxuw7/GewadQarFxw/UvIEZmjbyj5sqai9q8FRAPVCSsLc75+WXMFTsBOpc8xmM1FRUaSlpbF//35Xl3PB8fT0JCIiovSdtudKwe4CZrZYePD6txjrLGbpvqV8vf1rluxbwur01axOX4231ZuuPfvRZtMyrs7dTfB317C14GNadj/zP+rWnXMBONBwIKcbnRfTJIDF2w+yIukwd/QteVEzFitE9IRdv5aM5VKwc70TY+oa9ym5ovr7pxpnJ1KH2Ww2IiIiKC4uxuFwuLqcC4bFYsHNza1SrpAq2AluZjf6h/enf3h/0nPT+XbHt3yz4xsO5B1gYdpvLAyA1wPCaF1QQM/ld3Hg+H/od9HNp+wr/3guLY6tBhMEdb3ytPuM+WOc3crkIzicBhbzH/9jjupbEuySl0DP0ZV9qFJRySeCXd8/x0CmrYf8LHD3dV1dIlJlTCYTVqsVq9Xq6lLkHGgQk5QR6hXKPR3vYf7V85lx2Qzu7nA3bQLaALDFbudD/3r8Z8dUDh1JO+X22+J/wtNUQAYBNGnX67T7adPQB2+7Gzn5xWzen/XnihPj7HYvBad+W3SpwrySW7EAUf3ApyHUbwKGE3Yvd21tIiJySgp2ckoWs4X2Qe0Z03EMXwz7goXXLeTx7o8RUGyQbjXz2nenvpqWv2k2ACmBF2E6wzgBN4uZHtH1AYjfdfjPFQ06gN2n5IpQ+sbKOyCpuD0rwVkE3g2h/h+3y0ufXNbtWBGRmkjBTsol0COQa1pdxzUBwwCYZ97B9uSEMm2cDgfRR0r+wfdoO+ysfZ6Y9iQ+6S/BzuIGkX9c6dNYLtc68fOP6vfnm0Aa/xHsUjQljYhITaRgJxUy+vKniCo0k2s282bc2DLrdq5fQhBHOWZ40KLnpWftK6ZJSbBbnXyEIsdf5u9prKtCNcKJn/+Jq3Tw57lJ3wR5R6q/JhEROSMFO6kQi8WNEU3vAmCx7RDLf59Vuu7w2u8B2O7dHbu751n7ahXqg5+nldxCBxv3/WWc3YkgsXs5OIorrXapgIJjsH9dyd8b/yXYeYdAYAvAgN3LXFKaiIicnoKdVNi1A8bQvsCdYpOJ91c9Wbo8NG0BAM7mZ79aB2A2m+gRdYpxdiHtwN0PCnNKnsCU6pe6ApzF4BcB/pFl12mcnYhIjaVgJ+fk7u6PYzYMVrvn8+2vb7IvKZEo526KDTPNel9V7n5OTHuy4q/j7MzmknnToOTdsVL9TvzcTzyl/Fel4+wU7EREahoFOzknfTsOo3dREACf7Xqb1PivANhmb4tvQEi5+4lpEgjAmpSjFBafYpydwoNrpJxifN0JJ87NgS1w7GD11SQiImelYCfn7P4hL+PuNNhmN8jY9yEAOZEVe9VU85B6BHjZOF7kYP3ezD9XnAgUqSuguLCSKpZyyc/68xZ441MEO68ACC6Z21DBW0SkZlGwk3PWIrIDgyh5F+y79d0pAsJjrq5QHyaT6c9pT/46zi6oFXgGQFHen4P4pXrsXl4yCXH9aPBtdOo2UbqiKiJSEynYyXkZf+Ub+Bc72WO1MjEwgoCI070d9vR6NjlFsCszzk7hoVr99TVip6MpaUREaiSXB7vZs2fTo0cPPDw88Pf358orryyzPjU1laFDh+Lp6UlwcDAPPfQQxcWaAqOmCPJvyNV+QwCY5w3X/nQtCQcSKtTHiQco1qYeJb/oL68R02S4rnHi5x11igcnTmjcGzDB4R2QferXy4mISPVzabD75ptvGDFiBLfddhvr169n2bJl3HjjjaXrHQ4HQ4cOpbCwkOXLlzN9+nSmTZvG5MmTXVi1/N39V/+PF3s9T5BHECnZKdwy5xZeWP0C+cX55dq+SZAXQd52Coud/J6a+eeKE8FizyooLqj8wuVkeUdKJh+GP6+YnoqHPzRoX/L3lKVVX5eIiJSLyTAMwxU7Li4upnHjxjz55JOMGjXqlG3mzJnDsGHD2L9/PyEhJU9avv322zzyyCMcPHgQm81Wrn1lZ2fj6+tLVlYWPj4+lXYMUlZWQRbPrX6OH3f9CEBjn8ZM6jmJRvVOM07rL6b8tIVfEjO4rms4V3UK+2OpQehXwzAfP8SRfs9QFNCyzDZ+3oE0jWhb2YdRIceyj7JpxkTqtbuMtn3+4dJaKirzUDq52UfLLHPfu5SABQ9CYHO4d/WZO5g3CeJfh863wD9eq8JKRUQubBXJMW7VVNNJ1q1bx759+zCbzXTq1In09HQ6duzI888/T9u2Jf9Yx8fH065du9JQBxAbG8vo0aPZvHkznTp1OmXfBQUFFBT8eYUnOzu7ag9GAPC1+/J0n6cZEjmEJ+OfJCU7hTvn31nu7es1hZ8z4eeFf1kYaAcaQfIbkHzyNo2KDJobwbQNjuHSHqMID40+38OokC3T/k3PIz9xJGM2uR364eXtV637P1dbV86n2c/X4Wc69e91e/26EXbKNX8R1a8k2GmcnYhIjeGyW7FJSUkAPPHEEzz66KPMmjULf39/+vfvz5EjJe+gTE9PLxPqgNLv6enpp+176tSp+Pr6ln7Cw8Or6CjkVC4Kv4jvrviO4U2HU89aDw83j7N/LB6YDBuGs+zH7HTD3Wng4XSe9DEZBvusJhbaDvJa5o8MnfsPrnyvPY9Ou5qMw/uq/Dg3Lf2R7kd+AqA+2Wz49vkq32dlyVzzJRaTQaFhIc+wl35yDTvphj9fOs4wvu6EiBgwWeBoMmTtrfqiRUTkrCr9it2ECRN49tlnz9gmMTERp7NkMtpJkyZx9dUlU2R89NFHhIWF8dVXX/Gvf/3rnGuYOHEi48ePL/2enZ2tcFfNfO2+TOk9hSm9p1TZPvYeSGHuio/YmLGUHWSwx2Zil81gF9tZ/MMQLrF1Y+xVr+Hl6V3p+847lkX9Xx8EIMUcQWNnKq2Sp5GT9QDevvUrfX9lbP0ZFk0tuf3ZsOM5dRFyeBUAG3u8SJfLbitdvmTHQUZ8sIqG+90ZZxiYTKbTd+LuU7L/fWtLrtp1vOGcahERkcpT6cHugQceYOTIkWdsEx0dTVpayZN0rVu3Ll1ut9uJjo4mNTUVgNDQUFatWlVm24yMjNJ1p2O327Hb7edSvtQiYcGNueMff76rNjFpLXNWf8j8nMXss5r5wrGWRZ/F8A+/IYy+8lnc3KyVtu8NHz9ETyODdALx//dCdr92EZHOvcR/+ywxt535F5vzcuwAxd/djVtBFvm/TsV9xMwKd3E4Yy9Rzt0ARHUdUmZd18j6WC0m9mflk3okj8gArzN31rhvSbBLUbATEakJKv1WbFBQEC1btjzjx2az0aVLF+x2O9u2bSvdtqioiJSUFCIjS146HhMTw8aNGzlw4EBpm7i4OHx8fMoEQhGAVtFdGP/PN/j25pWMsMVQv9hJutXEu7lxXPVRZ177ejzph/ac9362rv6F7hlfAnDgomfx9Q/kUJdxALTZ/TFZR6ruNVsFsx7GrSALAOuuOMjJqHAfKWvnAZBsbkz94LIPtnjYLHQM9wP+Nq/g6URpPjsRkZrEZWPsfHx8uPvuu3n88ceZP38+27ZtY/To0QBce+21AAwZMoTWrVszYsQI1q9fz7x583j00UcZM2aMrsjJaXm6e/HwDe/y7dW/cqXREi+nk2QbvJsbx2WzLuXmd7ry4hejSdqzucJ9F+Tn4TFnLGaTwWrfWNoPuAaATpfcRrI5Eh/ySPx2amUfEgDG9nnYt35HsWFmtzMYCw5yV31c4X6Kd5XMU5cR2P2U60/MKxifVI5gF94TzG6QlQpHUypci4iIVC6XzmP3/PPPc/311zNixAi6devG7t27WbBgAf7+/gBYLBZmzZqFxWIhJiaGm2++mVtuuYUpU6pu3JbUHQF+ofxn5Fd8PuQbhjmiCCsyKDKZWO9ewLSCpQz/9Z/8891OPP3pSDbsWFGuPtd9OolI5x4O4UfzW/6c4sNssZDZ4wEA2u75jMxDp3+455wUHCP32/sBmGZcxhfu1wFQtOZjqOCMRQ2PlAxvsDe96JTrT7wJZPmuw5x1NiR7PWjUpeTvumonIuJyLpvHrjppHjs5Yenvs5ib8BEbi7eT9LdpEJsUmmhva8GQDrfRp+NlJ227a+MKIr6+DKvJwbqer9D5kpFl1jsdDpKf6UoTRxLxDW8h5q7Km9vt0NfjCdz0AXucQfw26EfquVsYOLsf9Uz5FN8yC7foM7z+6y8O7Esm+L2OOAwTx8buxNc/8KQ2+UUO2j85n8JiJ7+Mv4imwfXO3Omv/4ElL0D7f8JV757L4YmIyBnUinnsRFyhT6dh9Ok0DIB1WxYza+27bDy+mW22YnbZYBdb+W79IwSsfQir8ecToSbAhBNbWDBOkyd+jjhscxdjt9ixW+x0Cu7EP5r+g5yYh2Hp3XTYN5PDGY8QEHLW2eDO6njyKvw3fQTANw0f4P6+rSgodjJnTm+GG7+Ssfg9GpUz2KWunUswkOTWhGanCHUA7lYLnSP8WJF0hPikw2cPdlF9S4Jd8m8lVw/P9CStiIhUKQU7uWB1bn0RnVuX3I7cvnsD3y9/nfXZa9liL+Cw26lGKVj++BSRemhDmTUL9izgld9f4eLwi9nh1YSrc3ex4dunCBj99vkV6SjiyBejaYSTueZ+3DpiFCaTCXerhdw2N8CmXwlMnQv5WeDue9bunEkl4+sOB/Wg2RnaxUQHsiLpCCt2HWZEz8gzdxreAyw2yEmDw7sgsGkFDlBERCqTgp0I0DyyPQ9HltxG3H9wN79vW1g616JByWgFwzDwCQnH7uNNoaOQAkcBhY5CjuYfZU7yHDYd3sT83fOZHwwfFDVkaM5cNnw3kQYBzYgMbUmTsHYVnlNv0zdTaVuwk6NGPYKufgF/rz/vH188cCjbN4TR3LyX9GUzCB14z1n7C8taA4Bni4vP2C6mSQD/+wVWJJWMszvjfHZWDwjrBruXQcpvCnYiIi6kYCfyNw2DImkYNLJC29zS5ha2HdnG19u/ZnbSbPaRw7v1vSF7FmRT+jo0P4eTek4Tp3mT10ncjWJu9PbCO/QBYtu0KFunvydfBV9O80Nv4VgzDc4S7PYnb6WhcYAiw0KTroPO2LZDuC/uVjOHcwvZnnGMFqFnCaSN+5YEu+Ql0PX28hxaqfgPH8YtK5mOYz7FatPT7iIi58OlT8WK1CUt6rdgUs9J/Hrdr4yLvoOuBV40LzATXOzE7Y9nlDItZvZaTeyxle+zw27lycAAsrtEnHKfjQeMotCw0Oj4NnJS1p2xvn2/l8xft8vW4qzvtLW7WegaWfIGjfhdh85+8Cfms0tZWqGndHcnriUm9R26Zc1n64q55d5OREROTVfsRCqZh5sHt/e9n9v73l+6rLi4iD0Zu0jet4nD2eWfCmV13hbmHF3CU6v+Q30PfwZGDiyzvmvrpvxm68lFRctI/eUd2tzxzmn7MqWUTEdyNLhHufYd0ySApTsPEZ90mJG9o87cOKwbuLlD7gE4uA2CW5ZrHxlx/+PECL5j2xZAvyvKtZ2IiJyagp1INXBzsxLVqCVRjcoXeE64xjDwiH+Cb3d8y8O/Pcxbg96ie4M/JxY2mUwUdxgBa5YRsfcnnAX/w2z3PKkfw+kkInstAN6tzjy+7oSYP+azW5l8BKfTwGw+wzg7N3vJQxTJi0teL1aOYHfkwD7aH55b8sgx4J+xslx1iYjI6elWrEgNZjKZeKznYwyMGEihs5D7Ft7HlsNbyrTpOehq9hOIN7kkLvrslP3s3bWRYI5QaLjRtHP5gl27Rr542Sxk5hWRmJ599g1KXy/2W7n63zb7VdxNRew3hQDQpGg7uTmZ5dpWREROTcFOpIZzM7vxbL9n6R7andyiXEb/MpqUrJTS9V7uNrY3uBIA0++fnLKP/b/PB2CHvTXunmeZl+4PVouZblEnxtmV4/VijfuV/JmyFP54ovh0CvLzaLb7i5LaujzIflMwVpODXWt+KVdtIiJyagp2IrWA3WLnlQGv0Kp+K47kH+GuuLv4YOMHzEuZx+bDmwm++CachonW+QmsX/jVSdu7pS4FILtBrwrt98R7Y1eU572xjTqD1QuOH4EDW87YdP2cDwgkkwwC6DDkVvb6dgUgd/vCCtUnIiJlaYydSC1Rz1aPtwa9xci5I0nJTuHldS+XWe/VOJL2Bbk8sGwMa/OP0eXS24CS8XVRx0qemPVrXb7bsCeUjrNLOkKxw4mb5Qy/C1qsENETdv1aMs4utO0pmxlOJ0Eb3wcgOfomQmx2TFF94fefCTi4qkL1iYhIWbpiJ1KLBHgE8NElHzGm4xiGRg+lQ1AHAtxLwleu2Um8hwc3Nwpi5+ZHWfnNKwCkbF1LfbLJM+w06XhRhfbXpqEv3u5u5BQUs3l/RcbZLTltk83LfiLKmUKeYafVsPsAiOgSC0CToh1kZ5bj6qCIiJySrtiJ1DKBHoHc3eHuMsvyivJIzUnlpTUvEZ8Wz1NB9bk441VyZhyintmdKGCnR1va290rtC+L2USPqPr8kniA+KTDdAj3O/MGJ8bZ7V4KTgeYLSc1cSx/HYCNQcPoUT8IgJCwJuw1NSCMNJLWxtFx4PUVqlNEREroip1IHeBp9aRl/Za8PfhtHuzyABbDxAIvT6bmf82x3SW3PXMb9j6nvnv+Mc6uXA9QNOgANu+Sd9embzxp9e5tCXQ4vgqnYaLRJePLrNvvXzLOLl/j7EREzpmu2InUIWaTmVvbjqRbaDfumzWKDLdcxod60eu4BafPbn5cMhGbxYbNbMNmsWE2nf13u0OOAuzB+1iTbeLaL78/a/sW9SOoX7CPoF+eYUDss4SF/Dm5cfr8l4gE1nvF0Klp2TF45uh+cOQngg7V4nF2hgEJn5WML2zQwdXViMgFyGQYFXj/Ty2VnZ2Nr68vWVlZ+Pj4uLockWqRV5THQ1/cwG/OJJfVYDEMmhe60dLWjJ6RsfRfNBFPUyFbYr+gdcylZdoe2r+bwHfb4zRM5Ny3Dd+AEBdVfR52xMGMa6B+NNz3u6urEZE6oiI5RlfsROooT6snb4z4gR9+e58D5mN4BgRR5Cii0FlIoaPkY1C+3+vSsvLZfTi3XG3NRhGBOetJNvazx2Yi0e4gka18l7qVRuGBPHTInYt7xJ60XWDDSHabw4l07mHXmvl0jh1RoeOtEbbNKfnzSBIc3Q3+kWduLyJSyRTsROq4K/rd4bJ9r9u6hPnrprPl2HoSrcfZZ3Xj1YggBphK3yRWRnr9bkQe2kPRzkVQ24KdYcCO+X9+T1miYCci1U4PT4hIlencsi8Tbnyfj+9azXdXzMbT4kFSURrf7fjulO2tTUqeqg0+vLo6y6wcBxIha8+f388w5YuISFVRsBORahFWP5J7Oo0B4OV1L5NVkHVSm6iul5T86dzNkQP7qrW+87ZjXsmfHiWvYSNlSclVPBGRaqRgJyLV5sZWN9LEtwmZBZm8/vvrJ633D2pAsrkxAMlr5p+0vqI2L5tNQtxn591PueyIK/mzz1gwWyF7X8lYOxGRaqRgJyLVxmq2MrHHRAC+3P4lW49sPalNRkA3AIp3LTqvfa349AnaxN1Ix2WjSVw577z6OqvjRyF1RcnfW18BYSXHQIpux4pI9VKwE5Fq1aNBD2Ibx+I0nDy94mn+PuOSvVl/AEKPrjmn/g2nk/h3/03Pnf8rXVa08Llzrrdcdi0AwwGBLcC/cblerVZRmYfS2fxMP1Z8/kyl9SkidY+CnYhUuwe7PoiHmwcJBxOYlTSrzLrorrE4DRORzr0c2r+7Qv0WFxWy+rURxOz/GIAVITdQbJhpn7+G7esWV1r9J9n+x23jZoNL/mz8R7CrxHF2W+e+TZvC9TTb9jaG01kpfYpI3aNgJyLVLtQrlLva3wXAi2teJKcwp3Sdb/0gktyiAUhZV/5bqPnHc9n48nC6H52FwzCxqt2T9Bz9Nr/7DQEg95f/VuIR/IXTCTv/GF/X/I/5+cK6gcUOxzLg0I5K2Y1/SskceQFksS9pS6X0KSJ1j+axExGXuKX1Lfyw8wdSslN4fvXzXN7k8tJ1W4JbcPToXnbunEnyL4Xl6M3A5/eZxOZupNBwY1Ovl+n+xzx4IUMn4pwxj055y0natJLotj0q90D2r4O8w2D3gYiYkmVWdwjvXnLFLuU3CGp+XrvI2LuLFsV/jkdM27SYsL+9kk1EBBTsRMRFbBYbE7pP4O5f7ua7nd/x3c6/zG3nDjQIAQ7AvnfK12EwbD0SwMDur9C5958hMaJ5R9b69KdLzkKOzn0G2v5QqcfB9j+uKjYZABbrn8uj+pUEu+Ql0O38JolOXjKTv75gzblnJTDmvPoUkbpJwU5EXKZ3o97c3vZ2Fu1ZVGa5YTgpOLIXi7OoXP0YJthrNfF+fS/8/I7w92tZ/rET4euFdMpZzO5tCUS26FgZ5Zc48baJZn97Tdpfx9k5nWA+95Ev3sk/A7DF2pbWRZsIPppwzn2JSN2mYCciLjWuyzjGdRl33v28u+FdXvv9NV5Y8wIebh5c1+K60nXRbXvw+8+96JS3nAM/P0Nkiy/Pe38A5KRDWkLJ35sOKruuURewepbcpj2YCCFtzmkXhzP20rJgE5jA7dKn4ccriHSkknX0EL7+gedXv4jUOXp4QkTqhDvb3cmotqMAeGrFU/y066cy6+sNLpk/r1NmHPuSEitnpycmJW7YCbxDyq5zs0H4H+P5zmPak52/zcRiMthhaUrzzv3Za2qA2WSwO2HROfcpInWXgp2I1Akmk4n7O9/PDS1vwMDgsWWP8evuX0vXN+vUjw3u3XAzOdk7q5LmgjvxGrG/34Y9Ieovt2PPkceu2QAciijZR5pPewDydi0/5z5FpO5SsBOROsNkMjGh+wSuaHIFDsPBQ789RNzuOI7kH8FpOLENeBiATodnk75n5/ntrLgQTrwdo/mQU7eJuqjkz5SlJePsKijryEFaHU8AIKzXPwFwhpVcBax3cG2F+xORuk9j7ESkTjGbzDzR6wnyivOI2x3H+EXjAbCYLPi7++PVqDGNinMJ+fE2brrsVVpEdTq3HaXGQ2EOeAVBg9P00aAj2LwhPxMyNkKDDhXaxfbfZtLN5CDZHElUs5Jtg9v0g80QnZ9IcVEhblbbudUvInWSrtiJSJ3jZnbj2b7PMrzpcHztvgA4DAeHjh9it83Jck8PvquXyfWLR3DHuzF8t/BtnA5HxXZy4mnYpoNP/8SrxQ0i/5jb7hzG2Vm3l7yVIz3sz1u9kS06k40nnqYCUrasqnCfIlK3uTTYbd++nSuuuILAwEB8fHzo06cPCxcuLNMmNTWVoUOH4unpSXBwMA899BDFxcUuqlhEagurxcqU3lNYev1S1o1Yxy/X/MKXw77krUFvMdInlhYFZopNJlbajzE59Q2u+LAjz31+F7+s/Ird+7efFPScDgd7dqxnzY9vsfKNUWSvKHltWaJ3zEnvuy2j8bmNszuWfZRWuSXvyw3t+ecTvmaLhRT3kidsDydW3rtoRaRucOmt2GHDhtGsWTMWLFiAh4cHL7/8MsOGDWPXrl2EhobicDgYOnQooaGhLF++nLS0NG655RasVivPPKMXYYtI+VjNVkK8QgjxKnlytc/wPgDMj/+c7ze+xSrrEVJsJlIK4/lkazxsBZvTIMABvk43ghwWLso9zMC8LLr+ZaxcluHJdb940GrXCsYPbk7P6ICTd37iAYrdy8FRXHIVrxy2LvmarqYi9pga0rhllzLrckO6wO7VWPatPoefhojUZSbjjL9qVp1Dhw4RFBTEb7/9Rt++Jf/hy8nJwcfHh7i4OAYNGsScOXMYNmwY+/fvJySk5D/Ib7/9No888ggHDx7EZivf2JLs7Gx8fX3JysrCx8enyo5JRGqnPWk7+CjucdYVbOKwxUGm5fQ3M6IKzbSiAR0Ce5Lq7MOHv+dTWAxgoleTAB4Y0pwukfX/3MDpgOeiID8L7lxQMr9dOax74XI6H/uN+Ia3EnPXq2XWbVr6I21/GUE6QYQ+cZ4PgYhIjVeRHOOyYGcYBq1ataJv3768/PLL2O12Xn75ZZ5//nm2bt2Kv78/kydP5scffyQhIaF0u+TkZKKjo1m3bh2dOp16wHJBQQEFBQWl37OzswkPD1ewE5FyycnNZMfu9ezOSCTtaBKpBWlstRxh1/HU025jGOaSV2Bg5u+jXNwpxMKpx/B5OaGXpSV3X/YiYcGNATiem4PxXBM8TQXsuHIWzTr2LbNNbk4m9heicDM5ybhjHSFhTc7ncCtFYUE+if8bRpHNly5jv8J0Hm/aEJGyKhLsXHYr1mQy8csvv3DllVfi7e2N2WwmODiYuXPn4u/vD0B6enrplboTTnxPT08/bd9Tp07lySefrLriRaRO8/byo3Pri+jc+qIyyw8dP0T8/niW7FvC8v3LySrIKl1nMjnBBJwiwJX8mnnqoJNnhh/Yzi+zh9LP2Zi7Bj9LTuJaOpkK2G8Kpmn73idt4+Xtx063KJo6drF3w6IaEew2/jqDLvmrIR/2pSTSKPrc3rQhIuen0oPdhAkTePbZZ8/YJjExkRYtWjBmzBiCg4NZsmQJHh4evP/++1x++eWsXr2aBg0anHMNEydOZPz48aXfT1yxExE5H4EegVze5HIub3I5TsNJXlEeDsNR8nGW/Hk0L5/s4ye/49acfwRT0fGTlscn/sjco3Gk2szMMaey4NfriT3mwM/qRnr9i2l4mitfh/070vTQLopSVgCjKvtQK8y+/uPSv+/7fb6CnYiLVHqwe+CBBxg5cuQZ20RHR7NgwQJmzZrF0aNHSy8rvvnmm8TFxTF9+nQmTJhAaGgoq1aVfZw/IyMDgNDQ0NP2b7fbsdvt53cgIiJnYDaZqWerd9LyUK+K9dO1TX9GFxcx7eenmJ3+HTvt8KOPGz/6NKSeJYH2cf+iTUAb2ga2pU1Am9IHQCxRMXDoGwKO/F4Zh3Ne9uxYT9uChNLv5t1LgfN//6+IVFylB7ugoCCCgoLO2i4vLw8A899+GzWbzTj/eOosJiaGp59+mgMHDhAcHAxAXFwcPj4+tG7dupIrFxFxDTc3K3f840lud0zmi19e5qfdn7HVVsQxRx7L9y9n+f4/Xx92adSlPNPnGcLa9YfVEFW0i7xjWXjW83VZ/ft+eYtw4CD+BHGUyOy1GE6nxtmJuIDL/l8XExODv78/t956K+vXr2f79u089NBDJCcnM3ToUACGDBlC69atGTFiBOvXr2fevHk8+uijjBkzRlfkRKTOMVss3Bj7AJ/ftZaVI9bwxdAveKznYwxvOpxm/s0wm8zMSZ7DlPgpBDeK5gD1cTM5Sd6wzGU15x/PpUVGyUTKqd0fo8CwEsRR9uzc4LKaRC5kLgt2gYGBzJ07l2PHjnHxxRfTtWtXli5dyg8//ECHDiWvzrFYLMyaNQuLxUJMTAw333wzt9xyC1OmTHFV2SIi1cJmsdEmsA3XtbiOKb2n8O0/vuV//f+H2WTmu53f8UrCq+yp1x6AnO1LXVbnpl8+xZ8cMgigw+AR7LS3AiAtYb7LahK5kLl0guKuXbsyb968M7aJjIzk559/rqaKRERqrosjLuaJmCeYvHwyH276kJyQDnQ5Bh4Za1xWk+eGkocmkiKuJsRqI7tBL9i9AWvqUuBhl9UlcqHSAAgRkVpkeLPhjO08FoCvnOv5sZ4XjY9vqvi7bivB7sS1tC7ahMMwET3kbgD8Wl8MQONjv2P85S0dIlI9FOxERGqZ29vezq2tbwVgcmB91nuUvMe2uqUtfBuADV4xpXPpNel4EXmGnfpkk7J1bbXXJHKhU7ATEallTCYT47uO5x9N/oHDZOKB4ED+t/AeXvjibuYun0FObmaV15Cfd4zWB2YDYO52e+lym92dXe4lc9hlrI+r8jpEpCyXjrETEZFzYzaZeaLXEyTvXMFG8wF+9cyFgmWwYxlu26fSqMhEsOGJqZy/v5sxMbDxNVw/ZPzZGwMb50+jG7mkEUTbvsPLrDvWMAaS12Hf67qndUUuVAp2IiK1lNVs5b1//sDHc6aw88gG9jszSHUrJNtiZrcNdpNXof7W7P8Q5zwHN8Y+dNa23ps+BWB34+to4Fb2nxL/NgMh+Q2ichNwOhyYLZYK1SEi507BTkSkFvPyqMfoq54r/e50ONiUtJo1W+eRlpVc7n625m4iwb2Al/dPw29pCJf1ueW0bZM2raRlcSJFhoWml9x90vom7fuQ+5M7fqZj7Nq8kibte1XsoETknCnYiYjUIWaLhfbNetK+Wc8KbZeTm8ldMwawyV7MM9ufxd87iJgOl57UriA/j6NznwFgY73edA6NOKmN1WZni0c7OuSv5uDGXxTsRKqRHp4QERG8vfx4+epZNCkwkWUx89jqB0lMKvtUa8KvX3Dw2U50ObYIAHuvk6/WnXC8UUmYc9+3/LRtRKTyKdiJiAgAIQGNeOGSz2hYZJBhNfPQryPZeyCFPTs3sv7ZwXRc8i/CjHQO4s+abi/QpvfQ0/YV0HYQANF563EUF1fXIYhc8BTsRESkVNOItkzt9Qb1i53stsGD3w3DOuNiOhxfRaFhIb7BzXiM/52uQ+88Yz/R7XqRjSc+5JG0sYqu2h07CHGTYd+6qulfpBZSsBMRkTI6t76Ix9s9ST2Hk83uJmIjQ7iuYRPevfgRGt/0KPV8/M/ah8XNjSTPkvd+H970S+UXeXQ3fBgLy16BH++r/P5FaikFOxEROcnF3a9hYtPxRBbbcJpMJNqLeCflU4Z8M4TrZ13PR5s+Irco94x95P8xzs6zssfZZWwpCXVHdv3xfSOkb6rcfYjUUibDMAxXF1HVsrOz8fX1JSsrCx8fH1eXIyJSq+w7to8FqQv4Zfcv/H7gdwxK/tkIcA/gno73cFWzq3AznzzJwq4Ny2ny7aXkGXask/ZgtdnPv5jUlfDZdZCfCUGtwCsQUpZAr3/DkKfOv3+RGqgiOUbBTkREyu3Q8UMsSF3A9M3TSc1JBaCxT2PGdRnHgPABmEym0rZOh4Ps/0TgxzG2Dv2Glt0Gnd/Od8TBzBFQfBzCusONM2H3cph5E9QLhfFbwKzJkKXuUbD7GwU7EZHKVeQo4qvtX/H2+rc5WnAUgM7BnRnebDgW05/hKmX2izQu2EayR1sIaXPO+7MVZdF79xzaFhzH1HQwXDcdbF5QXAgvNofjR+Hmb6HpwPM+NpGaRsHubxTsRESqRk5hDh9t+oiPt3xMgaOgyvfXoMhKi5CbeaD3zTSuH1yycPYDsPp9aHcdXP1eldcgUt0U7P5GwU5EpGql56bzwcYPSm/PnlBcVETuvs2YjaLz6t8JbLU6cJidABhOC8GWrtzQ6lpuC/bD7aMhYPWEB7eD3fu89iVS0yjY/Y2CnYhI7bc36wgvLf+cxWmzKbTsKV3eyNKPuUfiS56SvfIt6HijC6sUqXwVyTGa7kRERGqFMN/6vHTpGNbe/jPPdP+AxrZBGIaZfY7feC+wZM481n/h2iJFXEzBTkREap3LW3Xnpxv+RyfvawB4LX8j6RYLJP8GWftcXJ2I6yjYiYhIrfXOPx7G7miMYSlgbEgETgzY+KWryxJxGQU7ERGptTytdl4Z+ByG08pmu4NPfLxLbsfW/eHjIqekYCciIrVa78hWXNrwXwC8Ut+P7Zm7IC3BtUWJuIiCnYiI1HrPDr4TP6MDRSYTE4IDyF33qatLEnEJBTsREan1zGYzHw57HqvDnR02G68mzwLH+c2dJ1IbKdiJiEid0CywASNbTADgc28rj3w0lO27E1xblEg1U7ATEZE6477eV9O3OALDZOJnaxo3LLiZMe/2Z8XG+a4uTaRaKNiJiEid8uqtP3C//1U0LzBTaDbxm/0wd60dz+3v9mB+/OeuLk+kSumVYiIiUic5HQ6+W/wO3+/4kAT3AgDcDIOnmz7MZX1ucXF1IuWnV4qJiMgFz2yxcPXF9/DJv9bwausnaFPgRrHJxLuJL1BYWODq8kSqhIKdiIjUeQO6Xc2U2I/wcjrZZTP439djXF2SSJVQsBMRkQtC88iOXG7tBsAP+fEk7dns4opEKp+CnYiIXDAeuPZNogohx2LmuTl3u7ockUqnYCciIhcMd7sno5rfD8AyeybfL3zHxRWJVK4qDXZPP/00vXr1wtPTEz8/v1O2SU1NZejQoXh6ehIcHMxDDz1EcXFxmTaLFi2ic+fO2O12mjZtyrRp06qybBERqcOuuOgO+hb4A/DBztfJL8hzcUUiladKg11hYSHXXnsto0ePPuV6h8PB0KFDKSwsZPny5UyfPp1p06YxefLk0jbJyckMHTqUAQMGkJCQwNixY7njjjuYN29eVZYuIiJ12END38XH4STFBi98qVuyUndUyzx206ZNY+zYsWRmZpZZPmfOHIYNG8b+/fsJCQkB4O233+aRRx7h4MGD2Gw2HnnkEWbPns2mTZtKt7v++uvJzMxk7ty55dq/5rETEZG/e+7zu/ikMB5Pp5OP+39Ki6hOri5J5JQqkmPcqqmmU4qPj6ddu3aloQ4gNjaW0aNHs3nzZjp16kR8fDyDBg0qs11sbCxjx449bb8FBQUUFPw5R1F2dnal1y4iIrXb+GvfYMWHXdhhN3PvryPwdVrKrDdjortPT8Zf+wZmi+U0vYjULC59eCI9Pb1MqANKv6enp5+xTXZ2NsePHz9lv1OnTsXX17f0Ex4eXgXVi4hIbebmZuWuto9gMQzSrSa22Z1lPol2B9MLlnHr+z3YvjvB1eWKlEuFr9hNmDCBZ5999oxtEhMTadmy5TkXdb4mTpzI+PHjS79nZ2cr3ImIyEku6XUTdqs7u9LWn7Qu5chmfmYbCe4F3P7rTdwScBV3XfEfF1QpUn4VDnYPPPAAI0eOPGOb6OjocvUVGhrKqlWryizLyMgoXXfizxPL/trGx8cHDw+PU/Zrt9ux2+3lqkFERC5sA7pdzQCuPuW6QWu+48XfJ5NiM/Na5vese3cRT1z1GaGBulggNVOFg11QUBBBQUGVsvOYmBiefvppDhw4QHBwMABxcXH4+PjQunXr0jY///xzme3i4uKIiYmplBpEREROp3/X4XRpNYApX9zIPEsqy+yZ3Pz9JbzQ5106tuzt6vJETlKlY+xSU1NJSEggNTUVh8NBQkICCQkJHDt2DIAhQ4bQunVrRowYwfr165k3bx6PPvooY8aMKb3idvfdd5OUlMTDDz/M1q1befPNN/nyyy8ZN25cVZYuIiICgLeXH8+P+pnHI+4huNggw2rm898ed3VZIqdUpcFu8uTJdOrUiccff5xjx47RqVMnOnXqxJo1awCwWCzMmjULi8VCTEwMN998M7fccgtTpkwp7SMqKorZs2cTFxdHhw4dePHFF3n//feJjY2tytJFRETKuPrie7i64XUAJBt7OZZ91MUViZysWuaxczXNYyciIpUh/Vgag78ZgskweNnrRi6+9v9cXZJcACqSY/SuWBERkXIKrdeABnhjmEzsSf3K1eWInETBTkREpAJ6Rw4EINmWyc71S11cjUhZCnYiIiIVMKDpYABWeLhz6Ld3XVyNSFkKdiIiIhXQNaQrFizss7rhm/kLuTmZri5JpJSCnYiISAV4Wj3pFNIJgA2eJjbP/8jFFYn8ScFORESkgmIalkySH+/hjl/iZy6uRuRPCnYiIiIVFNOgJNitdHcnung7O9cvc3FFIiUU7ERERCqodUBrfGw+HLOY2Wy3cVgPUUgNoWAnIiJSQRazhR4NegAlt2PbHJqnhyikRlCwExEROQc9G/QEYLGHD/VMx9k8f5prCxJBwU5EROScnHiAItHdQq7JhF/iDBdXJKJgJyIick7CvcMJqxeGA4N4d0+aF29n1XevurosucAp2ImIiJyjE1ftfgoumdeuU8ITbFrygytLkgucgp2IiMg5OhHsUvzdWOM9EKvJQcSvd5OSuKbCfaXt3sbKmf+lqLCgssuUC4iCnYiIyDnqHtods8lMUlYSwbe9SKK1DT7k4T7zeg6lp5a7H6fDwfHp19EjcSprv36+CiuWuk7BTkRE5Bz52n1pE9AGgHVH1tPgX9+yx9SQUA5y9P2ryDuWVa5+1v38PtHOFADqJ+lWrpw7BTsREZHzcGLak/j98fgFhmK66SuO4k2z4h1se/N6HMXFZ9y+qLCA0HUvlX5vXrydvTs3VWnNUncp2ImIiJyHE+PsVqStYPOhzYREtSDjso8oMKx0ylvO6nfvOeP2675/lTAjncP4kmgtufq3Z8knVV631E0KdiIiIuehY1BHPN08OZJ/hOtnX0/Pz3ry9KGPmdRmKPM8PWhz8EtWfffaKbc9nptD9JY3ANjR4l/ktL4BgAZ7ZmM4ndV2DFJ3KNiJiIicB6vFyjN9n6Fvo7742n0pdBaScDCBecfX8WBIEFeGNcBv81NsX7fopG3Xf/s8QRwljSA6DR9HywE3UmBYaezcQ/KW1dV/MFLrubm6ABERkdpuYMRABkYMxDAMUnNS2XBwA+sPrmfxnsWk56XzrwYBPDfndg41XERgaAQA2ZmHabnrAwD2dLifBu6e2N09+b1eDzrlLiVj+adEt+3hysOSWkhX7ERERCqJyWQi0ieSy5tczqM9H+WLYV/QxCeaQ24WHmzgztrp11BYkA/A5q+fwo9j7DaH0+Xy0aV9ONtcA0Bk2lzdjpUKU7ATERGpIgEeAUy7dDpNvCI5YrHwVNAxfnj/Zg6l76HDnpJ3yx7p8RAWtz9voLXpfy25hjsNjQNsW7vAVaVLLaVgJyIiUoX83P2YfvkMom0NybRYeNljC2unDcXTVMB2t+Z0HDyiTHt3z3ok+vYFIGvV564oWWoxBTsREZEq5mv35dOrv6YJ/mRbLDwR4mCNu52Cfo9iMp/8T7G143UANDn4C8VFhdVdrtRiCnYiIiLVwNvmzafXz6ZFoZ1jZjOjQkNYW/8ohmGc1LZ1nys4ijeBZJIYP8cF1UptpWAnIiJSTerZvXnv+rn0tDbFaYIX177I/QvvJ6ug7KvHrDY72wMuBuD4ui9cUarUUgp2IiIi1cjfO5B3b/iWx3o+htVsZeGehfxz1j/ZfHhzmXb1ulwPQMvMRRTk57miVKmFFOxERESqmclk4roW1/HJZZ/QqF4j9h3bx4ifRzAjcQZ5RSUhrlWPWA5QHx/y2PLbty6uWGoLk3Gqm/t1THZ2Nr6+vmRlZeHj4+PqckREREplFWTx2LLHWLhnIQBmk5lmfs1oH9SeehsTGH5wMYfc+9DtgR9cXKm4SkVyjIKdiIiIixmGwaeJn/Lxlo9Jz00/aX1UYRHTr/sNf99gF1QnrqZg9zcKdiIiUltk5Gaw8dBGNhzcQMLBBDZkrMNhMjElYgzDB9zt6vLEBSqSY/SuWBERkRokxCuEEK8QBkUOAmDEu91IsOezdf8KQMFOzkwPT4iIiNRgjdwaALAnN8nFlUhtUKXB7umnn6ZXr154enri5+d30vr169dzww03EB4ejoeHB61ateKVV145qd2iRYvo3Lkzdrudpk2bMm3atKosW0REpMaIDmgHwH4yXVuI1ApVGuwKCwu59tprGT169CnXr127luDgYD799FM2b97MpEmTmDhxIq+//nppm+TkZIYOHcqAAQNISEhg7Nix3HHHHcybN68qSxcREakROjUtuSW7x+okLz/XxdVITVctD09MmzaNsWPHkpmZeda2Y8aMITExkQULFgDwyCOPMHv2bDZt2lTa5vrrryczM5O5c+eWa/96eEJERGqr4uIien/SkTyzmdfaTKF/1+GuLkmqWUVyTI0bY5eVlUX9+vVLv8fHxzNo0KAybWJjY4mPjz9tHwUFBWRnZ5f5iIiI1EZublYiiqwAbEhe7OJqpKarUcFu+fLlzJw5k7vuuqt0WXp6OiEhIWXahYSEkJ2dzfHjx0/Zz9SpU/H19S39hIeHV2ndIiIiVamhKQCAlKxEF1ciNV2Fg92ECRMwmUxn/GzdurXChWzatIkrrriCxx9/nCFDhlR4+7+aOHEiWVlZpZ89e/acV38iIiKuFOnTAoD9zgMurkRqugrPY/fAAw8wcuTIM7aJjo6uUJ9btmxh4MCB3HXXXTz66KNl1oWGhpKRkVFmWUZGBj4+Pnh4eJyyP7vdjt1ur1ANIiIiNVWbiD6wfQl73ApxOhyYLRZXlyQ1VIWDXVBQEEFBQZVWwObNm7n44ou59dZbefrpp09aHxMTw88//1xmWVxcHDExMZVWg4iISE0W0/5S3LY9Q7bFzKak1bRv1tPVJUkNVaVj7FJTU0lISCA1NRWHw0FCQgIJCQkcO3YMKLn9OmDAAIYMGcL48eNJT08nPT2dgwcPlvZx9913k5SUxMMPP8zWrVt58803+fLLLxk3blxVli4iIlJj+Hj506jIBMCarfNdXI3UZFX6SrHJkyczffr00u+dOnUCYOHChfTv35+vv/6agwcP8umnn/Lpp5+WtouMjCQlJQWAqKgoZs+ezbhx43jllVcICwvj/fffJzY2tipLFxERqVEaGr7sJotdhxJcXYrUYNUyj52raR47ERGp7aZ8cjNfOdfTNd+Tj/610tXlSDWq1fPYiYiIyMmah3YFYJ9Fb5+Q01OwExERqQV6tx0KQJrVxP6Du11cjdRUCnYiIiK1QHiDZgQXOwGI3zi7QtsWFuRzaL/C4IVAwU5ERKSWaFTsCcDW/RUbY/f7O3fi/04Htqwo3zvWpfZSsBMREaklGtkaArAnL6nc2+Qfz6Xd4XlYTAY5qz+vqtKkhlCwExERqSWi6rcHIM2UWe5ttq+Yg6epAIDwI8sxnM6qKE1qCAU7ERGRWqJrs0EA7LEa5ObllGub45v/HI/X0DjA3l0bq6Q2qRkU7ERERGqJji364OV0UmQysXLTvLO2N5xOIg/9BkCOUfJ+9X1rZlVpjeJaCnYiIiK1hNliIaLICsCGlN/O2j5p0wpCOcRxw8amxrcC4LF7YZXWKK6lYCciIlKLNDQHAbA7e+tZ2x5Y+wMAW726EtrjGgCaH19Pft6xqitQXErBTkREpBaJ8G4BQJrz4FnbBuxbAEBRk1gat+zCAerjYSpkx+r5VVqjuI6CnYiISC3SLrIvAKluhTgdjtO2O7g/hebF2wGI7n0VJrOZFP8YAHK3nH18ntROCnYiIiK1SK/2l+FmGORYzGzYGX/adsnLvwVgu1tzAkMjAHBrPhiABgeXVX2h4hIKdiIiIrWIl6c3YUUmANZsizttO1tSye3Ww2EDS5c16Xk5xYaZSOce0nZvq9pCxSUU7ERERGqZRoYvAEmHN5xy/fHcHFrmrgEgpOvw0uW+/oHssLUEIHWVpj2pixTsREREapkwjygA9hfuO+X6bfGzcDcVkU4QUa27lVmX2bAfALaUBVVbpLiEgp2IiEgt07JhTwA22/L4eenHJ60v3FLytondgf0wmcv+Ux/YcSgAzY6tpaiwoIorleqmYCciIlLL/KPvHbQtsJJvNvHM9mdZmvBz6Tqnw0H0kSUAeLYbdtK2Tdr35ig+1DMdZ8daXbWraxTsREREahmbzc7LV/9E0wITWRYzk9c+xIYdKwDYuX4pgWSSa7jTvMclJ21rtljY5dMdgKyNc6q1bql6CnYiIiK1UEhAI14a+iVhRQYH3cw8svgOkvdt5ci6krdNbPPujt3d85TbGk1KnpQNylhabfVK9VCwExERqaWiGrXk2YveJ6jYyV6rifGzr8MnrWSaE0fTk6/WlW7X43IAmjp2cSh9T7XUKtVDwU5ERKQWa9+sJ1O6PI+vw8lOu8FLQQUcNZlp2vuq024TGBrOTksTAJJX/lRdpUo1cHN1ASIiInJ++nS8jP87dogndjzLSg93+jUOo9Fvt9Hcvzkt6reghX8Lov2i8bP74W3zxmq2cjC0L0337cK061fgHlcfglQSk2EYhquLqGrZ2dn4+vqSlZWFj4+Pq8sRERGpEjPjXuaD3R+SZj3zP+0ebh54YKN+3kE8nWCiHh7YsJvd8TB74OnmzRU97qVzy77VVLmcSUVyjIKdiIhIHZNVkMX2o9vZfnQ7245sY9vRbezO3k1uUW65+/B1OPlw4Oc0j2xfhZVKeSjY/Y2CnYiICBQ7i8ktyiW7MJucwhx279vKnuS1HMvPJLcwi7ziY+Q78tjCfvZbTXTMtzP9jpWYLRZXl35BU7D7GwU7ERGR8lu4+hse2Pw4RSYTI2wxPHzDu64u6YJWkRyjp2JFRESkjAHdruZKSwcAvspfzoqN811ckZSXgp2IiIic5P9umEabAjfyzSaei3+Q/II8V5ck5aBgJyIiIidxc7Pyf/3foJ7DyQ67wX8+u8nVJUk5KNiJiIjIKbVv3osbvYcAMNu0g5+XfuziiuRsFOxERETktMZc9QLdC+rhMJl4detzHM5Mr/R9OB0OdiQsoaiwoNL7vtAo2ImIiMhpmS0Wnrj8YwKLneyzmpj6zW2V2n9xUSEJL11Bs++HsfbLZyq17wuRgp2IiIicUXiDZowI/icAi8x72L47oVL6dToc/P76CDrnLgHAnramUvq9kCnYiYiIyFmNvGwSzQvMFJhNvBX38Hn3ZzidrH77LrplzS1dVv/47vPu90JXpcHu6aefplevXnh6euLn53fGtocPHyYsLAyTyURmZmaZdYsWLaJz587Y7XaaNm3KtGnTqqxmEREROZnZYuHqyFsA+M2yn827zu/q2soPH6THwa8BWNF4DAANHPspLio8v0IvcFUa7AoLC7n22msZPXr0WduOGjWK9u1Pfh9dcnIyQ4cOZcCAASQkJDB27FjuuOMO5s2bVxUli4iIyGlcP2gsLQssFJpNvLPg3K/arfj0CXru/QCAla3+j+4j/kOeYcdmcpC2e1tllXtBqtJg9+STTzJu3DjatWt3xnZvvfUWmZmZPPjggyete/vtt4mKiuLFF1+kVatW3HvvvVxzzTX873//q6qyRURE5BTMFgvXRd8BwBLrATZsX17hPlZ9/RI9d5b8Gx4fNYYe/3wEs8VCmlsjAA6nbKq8gi9ALh9jt2XLFqZMmcLHH3+M2XxyOfHx8QwaNKjMstjYWOLj40/bZ0FBAdnZ2WU+IiIicv6uHXQvbQrcKDaZeGfxxAptu33dIrpunAJAfINbiLn1z6dgMz0bA5CfllhptV6IXBrsCgoKuOGGG3j++eeJiIg4ZZv09HRCQkLKLAsJCSE7O5vjx4+fcpupU6fi6+tb+gkPD6/02kVERC5U1ze7G4Dl1sOs2byo3Nvl/vIsZpPBunoX0fPOV8qsK/RvCoD58I5Kq/NCVOFgN2HCBEwm0xk/W7duLVdfEydOpFWrVtx8880VLvxs/WZlZZV+9uzZU6n9i4iIXMiuHPAv2ufbKDaZeH/ZY+XaZnfiWjrlLcdpmAi4fAqmv92ls4W0AMAnN6Wyy72guFV0gwceeICRI0eesU10dHS5+lqwYAEbN27k669LnooxDAOAwMBAJk2axJNPPkloaCgZGRlltsvIyMDHxwcPD49T9mu327Hb7eWqQURERCruxjb/ZsOuF4m3HSV+w1xi2l9yxvYH5j5LJJBQrw+dW3Q8ab1fRFtYDQ2KdmM4nScFPymfCge7oKAggoKCKmXn33zzTZnbqatXr+b2229nyZIlNGnSBICYmBh+/vnnMtvFxcURExNTKTWIiIhIxQ3tM5IvNr9OgnsBH66YcsZgl7Z7Gx0zfwET1Bv40CnbNIxug9Mw4WvK5cihNOoHN6qq0uu0Ko3DqampJCQkkJqaisPhICEhgYSEBI4dOwZAkyZNaNu2beknKioKgFatWhEcHAzA3XffTVJSEg8//DBbt27lzTff5Msvv2TcuHFVWbqIiIicxYj2DwCw0pbNnGWfnLbd7lnPYzU52GTvSPPOF52yjYeXN+nmkgtHGcl6MvZcVWmwmzx5Mp06deLxxx/n2LFjdOrUiU6dOrFmTfknNYyKimL27NnExcXRoUMHXnzxRd5//31iY2OrsHIRERE5myExN9C9oB6GycTzW//L9t0bTmpz9GAaHQ78AIDRe/wZ+ztkL3mQMmfvlsov9gJhMk4MbKvDsrOz8fX1JSsrCx8fH1eXIyIiUmfsPZDCnT8OY6/VRIsCMx/dtBhvL7/S9fEfPEDMnvfZYWlK00mrzzh2bsWbd9LzwJesCLmBnqPfrobqa4eK5BiNTBQREZFzFhbcmMndX6Cew8k2u5OHZ1yO0+EA4Fj2UVrv+RyAnK73nvWBCFNgcwA8spOqtug6TMFOREREzktM+0sY0+AWzIbBUnsmz3x2GwCbfnoVX3LZY2pIh8EjztpPvUatAQjI312l9dZlCnYiIiJy3m6+9BGusXQE4CvHOj6Z/QzRO6YBkNb2X1jczj4RR0iTkleQNnBmkH88t6pKrdMU7ERERKRSTLpxOr0L/HCaTLyVMYPjbtkcoD4dht5Vru0DgsPIxhOLySAtWQ9QnAsFOxEREakUZouF52/6ieYFZnIsZm5rEMwL0V1Iyt1NeZ7VNJnNpLmVvAb06G5NeXIuFOxERESk0nh7+TE1djqhRQYH3dyYY2zjulnXMey7Yby67lW2Hdl2xpCX7dUYgIKMbdVUcd1S4TdPiIiIiJxJ88iOfH39byxJW8aCfQv5be9vpOak8t7G93hv43s09GpIz4Y9iWkQQ/cG3anvXr902+L6TSFrHtYjO114BLWX5rETERGRKpVXlMfivYuZlzKPJXuXUOgsLLO+Vf1WxDSMYWSbkSQvnkXn+HvZ4daMZo+W/4UGdVlFcoyu2ImIiEiV8rR6cmnUpVwadSl5RXmsO7CO+P3xrEhbwfaj20k8kkjikUSyCrK4LfIfEA8Ni/ZgOJ1nnftOylKwExERkWrjafWkT6M+9GnUB4BDxw/xc9LPPL/meeYkz2Fch/spNsx4mfI5kLab4EZRLq64dlEMFhEREZcJ9AhkROsRhHuHk1ecx6K030gzhwJwIOnkd8/KmSnYiYiIiEuZTCaubHolAN/v/J5DHo0ByN2f6LqiaikFOxEREXG5fzT5ByZMrMlYwx7fkit2HNrh2qJqIQU7ERERcblQr1BiGsYAEO9TDIBndpIrS6qVFOxERESkRhjedDgA8c4UHEBQQaprC6qFFOxERESkRhgQMQBvmzeHizNZ6eFOKIfIzcl0dVm1ioKdiIiI1Ah2i52hUUMBmFnPD4C0JL0ztiIU7ERERKTGuLLZlQAs8bKRZTaRmbrZtQXVMgp2IiIiUmO0rt+a5v7NKTLBHC8vijO2ubqkWkXBTkRERGqMv85p9523F9bMXa4tqJZRsBMREZEaZWj0UCyY2WK3k1WU7OpyahUFOxEREalR6rvXp2dAVwBWeubgKC52cUW1h4KdiIiI1Dj/bHczAHO8Pdi7W68WKy8FOxEREalx+ob3pX4xHLVYiNv0lavLqTUU7ERERKTGcTO70ckZAsCajIUurqb2ULATERGRGql31JUAbHQ7Qn5BnmuLqSUU7ERERKRGuqLfnfg6nGRbzHy/+B1Xl1MrKNiJiIhIjWSz2WlXHADA8t2zXFxN7aBgJyIiIjVWj0aDAdhoTqe4uMjF1dR8CnYiIiJSYw2/aAyeTieH3MzMWzHD1eXUeAp2IiIiUmP51qtP2yIfABZt+9LF1dR8CnYiIiJSo3UJ7AvABiMVp8Ph4mpqNgU7ERERqdGuvug+rIbBfquJpQmzXV1OjaZgJyIiIjVaSEAYbQrcAZi/YbqLq6nZqizYPf300/Tq1QtPT0/8/PxO227atGm0b98ed3d3goODGTNmTJn1GzZsoG/fvri7uxMeHs5zzz1XVSWLiIhIDdXRtxsAG4u3u7iSmq3Kgl1hYSHXXnsto0ePPm2bl156iUmTJjFhwgQ2b97ML7/8QmxsbOn67OxshgwZQmRkJGvXruX555/niSee4N13362qskVERKQGGt77XsyGQZIN1m1d4upyaiy3qur4ySefBEquyJ3K0aNHefTRR/npp58YOHBg6fL27duX/n3GjBkUFhby4YcfYrPZaNOmDQkJCbz00kvcddddVVW6iIiI1DDR4W1oUehGot3Bz6vfpXPLvq4uqUZy2Ri7uLg4nE4n+/bto1WrVoSFhXHdddexZ8+e0jbx8fH069cPm81Wuiw2NpZt27Zx9OjR0/ZdUFBAdnZ2mY+IiIjUbh08OwCw/vhGF1dSc7ks2CUlJeF0OnnmmWd4+eWX+frrrzly5AiDBw+msLAQgPT0dEJCQspsd+J7enr6afueOnUqvr6+pZ/w8PCqOxARERGpFpd3/xcA22zF7Ezd5OJqaqYKBbsJEyZgMpnO+Nm6dWu5+nI6nRQVFfHqq68SGxtLz549+fzzz9mxYwcLFy48p4M5YeLEiWRlZZV+/noVUERERGqn9s170aTAhGEy8f3y111dTo1UoTF2DzzwACNHjjxjm+jo6HL11aBBAwBat25duiwoKIjAwEBSU1MBCA0NJSMjo8x2J76Hhoaetm+73Y7dbi9XHSIiIlJ7tLO1YBdbScha7epSaqQKBbugoCCCgoIqZce9e/cGYNu2bYSFhQFw5MgRDh06RGRkJAAxMTFMmjSJoqIirFYrUDI2r0WLFvj7+1dKHSIiIlJ7xHa4le83TGSzvYA96UmEh5bvgtKFosrG2KWmppKQkEBqaioOh4OEhAQSEhI4duwYAM2bN+eKK67g/vvvZ/ny5WzatIlbb72Vli1bMmDAAABuvPFGbDYbo0aNYvPmzcycOZNXXnmF8ePHV1XZIiIiUoP16TSMyEIoNpmYuUhz2/5dlU13MnnyZKZP/3N26E6dOgGwcOFC+vfvD8DHH3/MuHHjGDp0KGazmYsuuoi5c+eWXp3z9fVl/vz5jBkzhi5duhAYGMjkyZM11YmIiMgFrIutNbvZwursla4upcYxGYZhuLqIqpadnY2vry9ZWVn4+Pi4uhwRERE5Dxu2L+em+JInZGf0eo/2zXq6uKKqVZEco3fFioiISK3SvnkvWhVYAPh2+cuuLaaGUbATERGRWqerd3cA1hZudnElNYuCnYiIiNQ6N/R/CDfDIMUGi9Z85+pyagwFOxEREal1whs0o0OBJwCz17/v4mpqDgU7ERERqZViggcCsJYUiouLXFxNzaBgJyIiIrXS9YMfwsvp5KCbme8Xv+vqcmoEBTsRERGplXzr1adjUX0AFu76ysXV1AwKdiIiIlJr9W88HIDf3Q6Sk5vp2mJqAAU7ERERqbWu6j+GgGInORYzM399ydXluJyCnYiIiNRaNpudLkYYAMvT57m4GtdTsBMREZFaLbbNSADWW3PZf3C3a4txMQU7ERERqdUGdb+O8EKDQrOJLxY85+pyXErBTkRERGo1s8VCF2srAFZmLXdxNa6lYCciIiK13rW9xmEyDLbYi1mxcb6ry3EZBTsRERGp9do370X7AncAvlp54T4dq2AnIiIidcLFDS8HYKV5zwU7p52CnYiIiNQJNw55iMBiJ1kWMx/Pe9rV5biEgp2IiIjUCe52T3qamwLw26FfXFyNayjYiYiISJ1xQ+9HMP/xEEX8hrmuLqfaKdiJiIhInfHXhyi+XvU/F1dT/RTsREREpE4Z0PAfAKw07yXr2BEXV1O9FOxERESkTrlxyIME/fEQxSfznnF1OdVKwU5ERETqFHe7Jz3MzQD47fCF9RCFgp2IiIjUOTf1nYjZMEi0O1ia8LOry6k2CnYiIiJS57Rt2oMOhR4AfLvmFRdXU30U7ERERKROuhAfolCwExERkTrppiEPE1TsJNti5oPZk11dTrVQsBMREZE6yWaz08etNQDf5S4kac9mF1dU9RTsREREpM566Jr3iCyETIuZ//x8O06Hw9UlVSkFOxEREamzvL38uL/do7gZBmvc83jju4dcXVKVUrATERGROm1wz39ymdEcgM+z55GYtNbFFVUdBTsRERGp8ybd8AlNCkzkWMw8HfevOntLVsFORERE6jxPdy/GdfkPNqfBevcCXv76364uqUoo2ImIiMgF4aIuV/APS1sAZuYtJmHbUhdXVPmqLNg9/fTT9OrVC09PT/z8/E7ZZvXq1QwcOBA/Pz/8/f2JjY1l/fr1Zdps2LCBvn374u7uTnh4OM8991xVlSwiIiJ13MTrp9OiwEye2cx/F/+b7KzDri6pUlVZsCssLOTaa69l9OjRp1x/7NgxLrnkEiIiIli5ciVLly7F29ub2NhYioqKAMjOzmbIkCFERkaydu1ann/+eZ544gnefffdqipbRERE6jCbzc6DMc9jdxpsthfz+Kc9WfLmHezducnVpVUKk2EYRlXuYNq0aYwdO5bMzMwyy9esWUO3bt1ITU0lPDwcgI0bN9K+fXt27NhB06ZNeeutt5g0aRLp6enYbDYAJkyYwPfff8/WrVvLXUN2dja+vr5kZWXh4+NTaccmIiIitdO7s57grUNfU2wy0eN4Pi+lHyLJozuWmLtp2+cKTOaaM1qtIjnGZVW3aNGCgIAAPvjgAwoLCzl+/DgffPABrVq1onHjxgDEx8fTr1+/0lAHEBsby7Zt2zh69Ohp+y4oKCA7O7vMR0REROSEu4Y9wRuD3sHdZGOlhzu3NwymUeEq2i0YyZb/9qMgP8/VJZ4TlwU7b29vFi1axKeffoqHhwf16tVj7ty5zJkzBzc3NwDS09MJCQkps92J7+np6afte+rUqfj6+pZ+TlwRFBERETmhV1hvpg/9hAD3ALbZbVwXFk2imydtCjey7uNHXF3eOalQsJswYQImk+mMn/LeIj1+/DijRo2id+/erFixgmXLltG2bVuGDh3K8ePHz+lgTpg4cSJZWVmlnz179pxXfyIiIlI3tQ5ozSeXfUKEdwSHzIXcHhHOeruN7vs+YevK+a4ur8LcKtL4gQceYOTIkWdsEx0dXa6+PvvsM1JSUoiPj8f8x33szz77DH9/f3744Qeuv/56QkNDycjIKLPdie+hoaGn7dtut2O328tVh4iIiFzYwr3D+eSyTxjzyxg2Hd7E7Q0a8HZ6Og3n3suxViup5+Pv6hLLrULBLigoiKCgoErZcV5eHmazGZPJVLrsxHen0wlATEwMkyZNoqioCKvVCkBcXBwtWrTA37/2/JBFRESkZqvvXp8PYj9g7MKxxKfFMzokmNczDrB32n30uO8TV5dXblU2xi41NZWEhARSU1NxOBwkJCSQkJDAsWPHABg8eDBHjx5lzJgxJCYmsnnzZm677Tbc3NwYMGAAADfeeCM2m41Ro0axefNmZs6cySuvvML48eOrqmwRERG5QHlaPXlt4Gv0bdSXArOJe0OCKD4+n/ULvnB1aeVWZdOdjBw5kunTp5+0fOHChfTv3x8oufr25JNPsmnTJsxmM506deLpp5+mZ8+epe03bNjAmDFjWL16NYGBgfz73//mkUcqNqBR052IiIhIeRU6Cnlg0QMs2rsIq2EwJeM4vW9fin9QA5fUU5EcU+Xz2NUECnYiIiJSEUWOIsYvHMeifYtxMwzGZIUw6t9xLpnfTsHubxTsREREpKKKnEXc+9MdLM9ch5th0C3fC5vFA6vJht1sx2Zxx2b2oFPUxQztM7LK6qhIjqnQwxMiIiIiFwqr2cobl3/Avz4eyirTfuI98oC/TVzshLwdOVUa7CpCwU5ERETkNNzMbrxz8yw+/Pk/pGXuoNCRT6GzoORjFFJEMY1D2rq6zFIKdiIiIiJn4OZm5a5/THF1GeVSc95wKyIiIiLnRcFOREREpI5QsBMRERGpIxTsREREROoIBTsRERGROkLBTkRERKSOULATERERqSMU7ERERETqCAU7ERERkTpCwU5ERESkjlCwExEREakjFOxERERE6ggFOxEREZE6QsFOREREpI5wc3UB1cEwDACys7NdXImIiIhIxZzILyfyzJlcEMEuJycHgPDwcBdXIiIiInJucnJy8PX1PWMbk1Ge+FfLOZ1O9u/fj7e3NyaTqUr2kZ2dTXh4OHv27MHHx6dK9iHVQ+ey7tC5rDt0LusOncuKMwyDnJwcGjZsiNl85lF0F8QVO7PZTFhYWLXsy8fHR/9DrSN0LusOncu6Q+ey7tC5rJizXak7QQ9PiIiIiNQRCnYiIiIidYSCXSWx2+08/vjj2O12V5ci50nnsu7Quaw7dC7rDp3LqnVBPDwhIiIiciHQFTsRERGROkLBTkRERKSOULATERERqSMU7ERERETqCAW7SvLGG2/QuHFj3N3d6dGjB6tWrXJ1SXIGU6dOpVu3bnh7exMcHMyVV17Jtm3byrTJz89nzJgxBAQEUK9ePa6++moyMjJcVLGU13//+19MJhNjx44tXaZzWXvs27ePm2++mYCAADw8PGjXrh1r1qwpXW8YBpMnT6ZBgwZ4eHgwaNAgduzY4cKK5VQcDgePPfYYUVFReHh40KRJE/7zn/+UedepzmXVULCrBDNnzmT8+PE8/vjjrFu3jg4dOhAbG8uBAwdcXZqcxuLFixkzZgwrVqwgLi6OoqIihgwZQm5ubmmbcePG8dNPP/HVV1+xePFi9u/fz1VXXeXCquVsVq9ezTvvvEP79u3LLNe5rB2OHj1K7969sVqtzJkzhy1btvDiiy/i7+9f2ua5557j1Vdf5e2332blypV4eXkRGxtLfn6+CyuXv3v22Wd56623eP3110lMTOTZZ5/lueee47XXXitto3NZRQw5b927dzfGjBlT+t3hcBgNGzY0pk6d6sKqpCIOHDhgAMbixYsNwzCMzMxMw2q1Gl999VVpm8TERAMw4uPjXVWmnEFOTo7RrFkzIy4uzrjooouM+++/3zAMncva5JFHHjH69Olz2vVOp9MIDQ01nn/++dJlmZmZht1uNz7//PPqKFHKaejQocbtt99eZtlVV11l3HTTTYZh6FxWJV2xO0+FhYWsXbuWQYMGlS4zm80MGjSI+Ph4F1YmFZGVlQVA/fr1AVi7di1FRUVlzmvLli2JiIjQea2hxowZw9ChQ8ucM9C5rE1+/PFHunbtyrXXXktwcDCdOnXivffeK12fnJxMenp6mXPp6+tLjx49dC5rmF69evHrr7+yfft2ANavX8/SpUu59NJLAZ3LquTm6gJqu0OHDuFwOAgJCSmzPCQkhK1bt7qoKqkIp9PJ2LFj6d27N23btgUgPT0dm82Gn59fmbYhISGkp6e7oEo5ky+++IJ169axevXqk9bpXNYeSUlJvPXWW4wfP57/+7//Y/Xq1dx3333YbDZuvfXW0vN1qv/e6lzWLBMmTCA7O5uWLVtisVhwOBw8/fTT3HTTTQA6l1VIwU4ueGPGjGHTpk0sXbrU1aXIOdizZw/3338/cXFxuLu7u7ocOQ9Op5OuXbvyzDPPANCpUyc2bdrE22+/za233uri6qQivvzyS2bMmMFnn31GmzZtSEhIYOzYsTRs2FDnsorpVux5CgwMxGKxnPSEXUZGBqGhoS6qSsrr3nvvZdasWSxcuJCwsLDS5aGhoRQWFpKZmVmmvc5rzbN27VoOHDhA586dcXNzw83NjcWLF/Pqq6/i5uZGSEiIzmUt0aBBA1q3bl1mWatWrUhNTQUoPV/6723N99BDDzFhwgSuv/562rVrx4gRIxg3bhxTp04FdC6rkoLdebLZbHTp0oVff/21dJnT6eTXX38lJibGhZXJmRiGwb333st3333HggULiIqKKrO+S5cuWK3WMud127ZtpKam6rzWMAMHDmTjxo0kJCSUfrp27cpNN91U+nedy9qhd+/eJ007tH37diIjIwGIiooiNDS0zLnMzs5m5cqVOpc1TF5eHmZz2YhhsVhwOp2AzmWVcvXTG3XBF198YdjtdmPatGnGli1bjLvuusvw8/Mz0tPTXV2anMbo0aMNX19fY9GiRUZaWlrpJy8vr7TN3XffbURERBgLFiww1qxZY8TExBgxMTEurFrK669PxRqGzmVtsWrVKsPNzc14+umnjR07dhgzZswwPD09jU8//bS0zX//+1/Dz8/P+OGHH4wNGzYYV1xxhREVFWUcP37chZXL3916661Go0aNjFmzZhnJycnGt99+awQGBhoPP/xwaRudy6qhYFdJXnvtNSMiIsKw2WxG9+7djRUrVri6JDkD4JSfjz76qLTN8ePHjXvuucfw9/c3PD09jeHDhxtpaWmuK1rK7e/BTuey9vjpp5+Mtm3bGna73WjZsqXx7rvvllnvdDqNxx57zAgJCTHsdrsxcOBAY9u2bS6qVk4nOzvbuP/++42IiAjD3d3diI6ONiZNmmQUFBSUttG5rBomw/jLNNAiIiIiUmtpjJ2IiIhIHaFgJyIiIlJHKNiJiIiI1BEKdiIiIiJ1hIKdiIiISB2hYCciIiJSRyjYiYiIiNQRCnYiIiIidYSCnYiIiEgdoWAnIiIiUkco2ImIiIjUEQp2IiIiInXE/wNZX81kkN7j6gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Method: DUSB\n",
      ">> time cost: 0.11\n",
      ">> avg. energy = -88.43656\n",
      ">> Method: SB\n",
      ">> time cost: 0.09\n",
      ">> avg. energy = -87.93552\n",
      ">> avg. obj = -90.05924\n"
     ]
    }
   ],
   "source": [
    "# run_cfg='baseline'\n",
    "run_cfg = \"DU_SB\"\n",
    "BASE_PATH = Path.cwd()\n",
    "LOG_PATH = BASE_PATH / \"log_qaia\"\n",
    "DU_SB_weights = LOG_PATH / \"DU-SB_T=15_lr=0.0001.json\"\n",
    "class Judger:\n",
    "    def __init__(self, test_cases):\n",
    "        self.test_cases = test_cases\n",
    "    @staticmethod\n",
    "    def infer(J, h, qaia_mld_solver):\n",
    "        bits = qaia_mld_solver(J, h, run_cfg, DU_SB_weights)\n",
    "        return bits\n",
    "    def benchmark(self, qaia_mld_solver):\n",
    "        energy_list = []\n",
    "        obj_list = []\n",
    "        avgenergy = 0\n",
    "        avgobj = 0\n",
    "        t1 = time.time()\n",
    "        for case in tqdm(self.test_cases):\n",
    "            J, h, obj_val = case\n",
    "            energy = self.infer(J, h, qaia_mld_solver)\n",
    "            avgenergy += energy[0]\n",
    "            energy_list.append(energy)\n",
    "        t2 = time.time()\n",
    "        global run_cfg\n",
    "        avgsbenergy = 0\n",
    "        run_cfg = \"baseline\"\n",
    "        sbenergy_list = []\n",
    "        t3 = time.time()\n",
    "        for case in tqdm(self.test_cases):\n",
    "            J, h, obj_val = case\n",
    "            energy = self.infer(J, h, qaia_mld_solver)\n",
    "            avgsbenergy += energy[0]\n",
    "            avgobj += obj_val\n",
    "            sbenergy_list.append(energy)\n",
    "            obj_list.append(obj_val)\n",
    "        t4 = time.time()\n",
    "        avgobj /= len(self.test_cases)\n",
    "        avgenergy /= len(self.test_cases)\n",
    "        avgsbenergy /= len(self.test_cases)\n",
    "        BASE_PATH = Path.cwd()\n",
    "        LOG_PATH = BASE_PATH / \"log_qaia\"\n",
    "        LOG_PATH.mkdir(exist_ok=True)\n",
    "        pairs = list(zip(obj_list, energy_list, sbenergy_list))\n",
    "        pairs.sort(reverse=True)\n",
    "        DUSB_list = [D_energy for G_energy, D_energy, SB_energy in pairs]\n",
    "        SB_list = [SB_energy for G_energy, D_energy, SB_energy in pairs]\n",
    "        Gurobi_list = [G_energy for G_energy, D_energy, SB_energy in pairs]\n",
    "        plt.plot(DUSB_list, label=f\"DUSB\")\n",
    "        plt.plot(SB_list, label=f\"SB\")\n",
    "        plt.plot(Gurobi_list, label=\"Gurobi\")\n",
    "        plt.legend()\n",
    "        plt.suptitle(\"Energy\")\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(LOG_PATH / \"solut.png\", dpi=400)\n",
    "        plt.show()\n",
    "        plt.close()\n",
    "        tt1 = t2 - t1\n",
    "        tt2 = t4 - t3\n",
    "        return avgenergy, avgsbenergy, avgobj, tt1, tt2\n",
    "\n",
    "dataset = []\n",
    "folder = \"test_dataset\"\n",
    "files = sorted(os.listdir(folder))\n",
    "N = 12  # 固定变量数\n",
    "for idx, filename in enumerate(tqdm(files)):\n",
    "    filepath = os.path.join(folder, filename)\n",
    "    with open(filepath, \"r\") as f:\n",
    "        data = json.load(f)\n",
    "    h = np.zeros(N)\n",
    "    J = np.zeros((N, N))\n",
    "    hyperedges = data[\"J\"]\n",
    "    coeffs = data[\"c\"]\n",
    "    for edge, coef in zip(hyperedges, coeffs):\n",
    "        if len(edge) == 1:\n",
    "            h[edge[0]] += coef\n",
    "        elif len(edge) == 2:\n",
    "            i, j = edge\n",
    "            J[i, j] += coef\n",
    "            J[j, i] += coef\n",
    "        else:\n",
    "            print(\"warning: invalid input\", edge)\n",
    "    label = data.get(\"label\", None)\n",
    "    if label is not None:\n",
    "        obj_val = label.get(\"obj_val\", None)\n",
    "    J = -J\n",
    "    h = -h\n",
    "    dataset.append((J, h, obj_val))\n",
    "judger = Judger(dataset)\n",
    "avgenergy, avgsbenergy, avgobj, tt1, tt2 = judger.benchmark(qaia_mld_solver)\n",
    "print(f\">> Method: DUSB\")\n",
    "print(f\">> time cost: {tt1:.2f}\")\n",
    "print(f\">> avg. energy = {avgenergy:.5f}\")\n",
    "print(f\">> Method: SB\")\n",
    "print(f\">> time cost: {tt2:.2f}\")\n",
    "print(f\">> avg. energy = {avgsbenergy:.5f}\")\n",
    "print(f\">> avg. obj = {avgobj:.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db94a0a7",
   "metadata": {},
   "source": [
    "## 4 项目总结\n",
    "\n",
    "综上所述，本项目基于 MindSpore Quantum 将弹道模拟分岔机算法转换为可微的形式，然后利用梯度下降法实现了深度展开量子启发式算法。该算法可以自动调参，改善求解性能。比较了不同案例下基线方法和深度展开方法的计算效果，结果与预期一致。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71582b60",
   "metadata": {},
   "source": [
    "## 参考文献\n",
    "\n",
    "[1] Goto H, Endo K, Suzuki M, et al. High-performance combinatorial optimization based on classical mechanics[J]. Science Advances, 2021, 7(6): eabe7953.\n",
    "\n",
    "[2] Zeng Q G, Cui X P, Liu B, et al. Performance of quantum annealing inspired algorithms for combinatorial optimization problems[J]. Communications Physics, 2024, 7(1): 249.\n",
    "\n",
    "[3] Takabe S. Deep unfolded simulated bifurcation for massive MIMO signal detection[J]. arXiv preprint arXiv:2306.16264, 2023."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "lsw_qaia",
   "language": "python",
   "name": "qaia"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
